dingvero/hfut-bishe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

增加摄像机

Browse Source
This commit is contained in:
DingVero
2026-04-23 13:11:36 +08:00
parent a78b290920
commit 974946cee4
12 changed files with 1134 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
client/gui/CMakeLists.txt
View File

@@ -23,6 +23,7 @@ set(GUI_SOURCES
${GUI_ROOT}/props/BlackholePropertySection.cpp
${GUI_ROOT}/props/EntityPropertySection.cpp
${GUI_ROOT}/props/ToolPropertySection.cpp
${GUI_ROOT}/props/CameraPropertySection.cpp
${GUI_ROOT}/timeline/TimelineWidget.cpp
)
@@ -47,6 +48,7 @@ set(GUI_HEADERS
${GUI_ROOT}/props/BlackholePropertySection.h
${GUI_ROOT}/props/EntityPropertySection.h
${GUI_ROOT}/props/ToolPropertySection.h
${GUI_ROOT}/props/CameraPropertySection.h
${GUI_ROOT}/props/PropertySectionWidget.h
${GUI_ROOT}/timeline/TimelineWidget.h
)

215
client/gui/editor/EditorCanvas.cpp
View File

@@ -33,6 +33,10 @@
namespace {
// 摄像机「输出」参考分辨率：视口框与预览缩放均按此换算，避免随窗口大小改变镜头覆盖的世界范围
constexpr double kCameraRefViewportW = 1600.0;
constexpr double kCameraRefViewportH = 900.0;
constexpr int kSamCropMargin = 32;
constexpr int kMinStrokePointsSam = 4;
constexpr int kMinStrokePointsManual = 8;
@@ -63,6 +67,13 @@ static QImage readImageTolerant(const QString& absPath) {
return reader.read();
}
QRectF cameraWorldViewportRect(const core::Project::Camera& cam) {
const double s = std::max(1e-9, cam.viewScale);
const double halfW = (kCameraRefViewportW * 0.5) / s;
const double halfH = (kCameraRefViewportH * 0.5) / s;
return QRectF(cam.centerWorld.x() - halfW, cam.centerWorld.y() - halfH, 2.0 * halfW, 2.0 * halfH);
}
QRectF clampRectTopLeftToBounds(const QRectF& rect, const QRectF& bounds) {
if (rect.isNull() || bounds.isNull()) {
return rect;
@@ -518,6 +529,26 @@ void EditorCanvas::dropEvent(QDropEvent* e) {
e->acceptProposedAction();
}
void EditorCanvas::setPreviewCameraViewLocked(bool on) {
m_previewCameraViewLocked = on;
}
void EditorCanvas::applyCameraViewport(const QPointF& centerWorld, double viewScale) {
// 与 cameraWorldViewportRect 一致：viewScale 表示在 1600×900 参考视口下的像素/世界比；
// 实际画布用 min(宽/1600, 高/900) 将参考视口适配进当前控件，使可见世界宽高恒为 1600/s × 900/s。
const double pixelRatio =
std::min(static_cast<double>(std::max(1, width())) / kCameraRefViewportW,
static_cast<double>(std::max(1, height())) / kCameraRefViewportH);
const double eff = std::max(1e-9, static_cast<double>(viewScale)) * pixelRatio;
m_scale = std::clamp(static_cast<qreal>(eff), 0.05, 50.0);
m_pan = QPointF(width() / 2.0, height() / 2.0) - QPointF(centerWorld.x() * m_scale, centerWorld.y() * m_scale);
update();
}
QPointF EditorCanvas::viewCenterWorld() const {
return viewToWorld(QPointF(width() / 2.0, height() / 2.0));
}
void EditorCanvas::setPresentationPreviewMode(bool on) {
if (m_presentationPreviewMode == on) {
return;
@@ -715,12 +746,73 @@ void EditorCanvas::setTools(const QVector<core::Project::Tool>& tools, const QVe
update();
}
void EditorCanvas::setCameraOverlays(const QVector<core::Project::Camera>& cameras,
const QString& selectedId,
const QSet<QString>& tempHiddenCameraIds) {
m_cameraOverlays = cameras;
m_tempHiddenCameraIds = tempHiddenCameraIds;
m_selectedCameraId = selectedId;
m_selectedCameraIndex = -1;
if (!selectedId.isEmpty()) {
for (int i = 0; i < m_cameraOverlays.size(); ++i) {
if (m_cameraOverlays[i].id == selectedId) {
m_selectedCameraIndex = i;
break;
}
}
}
if (m_selectedCameraIndex < 0) {
m_selectedCameraId.clear();
m_draggingCamera = false;
}
update();
}
void EditorCanvas::selectCameraById(const QString& id) {
if (id.isEmpty()) {
clearCameraSelection();
return;
}
clearEntitySelection();
m_selectedTool = -1;
m_draggingTool = false;
emit selectedToolChanged(false, QString(), QPointF());
clearBlackholeSelection();
for (int i = 0; i < m_cameraOverlays.size(); ++i) {
if (m_cameraOverlays[i].id == id) {
m_selectedCameraIndex = i;
m_selectedCameraId = id;
const auto& c = m_cameraOverlays[i];
emit selectedCameraChanged(true, id, c.centerWorld, c.viewScale);
update();
return;
}
}
clearCameraSelection();
}
void EditorCanvas::clearCameraSelection() {
if (m_selectedCameraId.isEmpty() && m_selectedCameraIndex < 0 && !m_draggingCamera) {
return;
}
m_selectedCameraId.clear();
m_selectedCameraIndex = -1;
m_draggingCamera = false;
emit selectedCameraChanged(false, QString(), QPointF(), 1.0);
update();
}
void EditorCanvas::setTempHiddenIds(const QSet<QString>& entityIds, const QSet<QString>& toolIds) {
m_tempHiddenEntityIds = entityIds;
m_tempHiddenToolIds = toolIds;
update();
}
void EditorCanvas::setTempHiddenCameraIds(const QSet<QString>& cameraIds) {
m_tempHiddenCameraIds = cameraIds;
update();
}
void EditorCanvas::setCurrentFrame(int frame) {
if (m_currentFrame == frame) {
return;
@@ -879,8 +971,10 @@ void EditorCanvas::clearEntitySelection() {
void EditorCanvas::selectEntityById(const QString& id) {
if (id.isEmpty()) {
clearEntitySelection();
clearCameraSelection();
return;
}
clearCameraSelection();
for (int i = 0; i < m_entities.size(); ++i) {
if (m_entities[i].id != id) {
continue;
@@ -1608,6 +1702,30 @@ void EditorCanvas::paintEvent(QPaintEvent* e) {
}
}
// 摄像机视口框（编辑模式）
if (!m_presentationPreviewMode) {
const qreal handleRWorld = 10.0 / std::max(m_scale, 0.001);
for (int i = 0; i < m_cameraOverlays.size(); ++i) {
const auto& cam = m_cameraOverlays[i];
if (!cam.visible || cam.id.isEmpty() || m_tempHiddenCameraIds.contains(cam.id)) {
continue;
}
const QRectF camRect = cameraWorldViewportRect(cam);
QColor fill(80, 140, 255, 38);
QColor border(80, 140, 255, 170);
if (i == m_selectedCameraIndex) {
border = QColor(255, 170, 60, 230);
fill = QColor(255, 170, 60, 48);
}
p.setBrush(fill);
p.setPen(QPen(border, 1.5 / std::max(m_scale, 0.001)));
p.drawRect(camRect);
p.setBrush(QColor(255, 210, 120, 230));
p.setPen(QPen(QColor(30, 30, 30, 160), 1.0 / std::max(m_scale, 0.001)));
p.drawEllipse(cam.centerWorld, handleRWorld, handleRWorld);
}
}
// 创建实体：手绘轨迹预览（world 坐标）
if (!m_presentationPreviewMode && m_tool == Tool::CreateEntity && m_drawingEntity && m_strokeWorld.size() >= 2) {
QPen pen(QColor(255, 120, 0, 220), 2.0 / std::max<qreal>(m_scale, 0.001));
@@ -1840,11 +1958,13 @@ void EditorCanvas::mousePressEvent(QMouseEvent* e) {
emit presentationEntityIntroRequested(ent.id, anchorView);
return;
}
m_dragging = true;
m_presBgPanSession = true;
m_presBgDragDist = 0.0;
m_lastMouseView = e->position();
setCursor(Qt::ClosedHandCursor);
if (!m_previewCameraViewLocked) {
m_dragging = true;
m_presBgPanSession = true;
m_presBgDragDist = 0.0;
m_lastMouseView = e->position();
setCursor(Qt::ClosedHandCursor);
}
return;
}
if (e->button() == Qt::MiddleButton) {
@@ -1905,6 +2025,42 @@ void EditorCanvas::mousePressEvent(QMouseEvent* e) {
}
if (m_tool == Tool::Move && e->button() == Qt::LeftButton) {
// 摄像机：绘制在工具之上，命中优先于工具
if (!m_presentationPreviewMode) {
const qreal handleRWorld = 12.0 / std::max(m_scale, 0.001);
for (int idx = static_cast<int>(m_cameraOverlays.size()) - 1; idx >= 0; --idx) {
const auto& cam = m_cameraOverlays[idx];
if (!cam.visible || cam.id.isEmpty() || m_tempHiddenCameraIds.contains(cam.id)) {
continue;
}
const QRectF camRect = cameraWorldViewportRect(cam);
const double dist = QLineF(worldPos, cam.centerWorld).length();
const bool inHandle = dist <= handleRWorld;
const bool inRect = camRect.contains(worldPos);
if (!inHandle && !inRect) {
continue;
}
m_selectedCameraIndex = idx;
m_selectedCameraId = cam.id;
m_selectedEntity = -1;
m_selectedTool = -1;
m_draggingTool = false;
m_draggingEntity = false;
emit selectedEntityChanged(false, QString(), 0, QPointF());
emit selectedToolChanged(false, QString(), QPointF());
if (inHandle) {
m_draggingCamera = true;
m_cameraDragOffsetWorld = worldPos - cam.centerWorld;
m_cameraDragStartCenterWorld = cam.centerWorld;
} else {
m_draggingCamera = false;
}
emit selectedCameraChanged(true, cam.id, cam.centerWorld, cam.viewScale);
update();
return;
}
}
// 工具（气泡）优先命中：绘制在实体之后，交互也应优先
for (qsizetype i = m_tools.size(); i > 0; --i) {
const qsizetype idx = i - 1;
@@ -1914,6 +2070,7 @@ void EditorCanvas::mousePressEvent(QMouseEvent* e) {
if (tv.tool.type != core::Project::Tool::Type::Bubble) continue;
const QPainterPath path = bubblePathWorld(tv.tool);
if (path.contains(worldPos)) {
clearCameraSelection();
m_selectedTool = static_cast<int>(idx);
m_selectedEntity = -1;
m_draggingTool = true;
@@ -1940,6 +2097,7 @@ void EditorCanvas::mousePressEvent(QMouseEvent* e) {
const QPointF originView = worldToView(originWorld);
const GizmoHit gh = hitTestGizmo(e->position(), originView);
if (gh.mode == DragMode::AxisX || gh.mode == DragMode::AxisY) {
clearCameraSelection();
m_dragging = true;
m_draggingEntity = true;
m_dragMode = gh.mode;
@@ -1983,6 +2141,7 @@ void EditorCanvas::mousePressEvent(QMouseEvent* e) {
hitSelected = ent.rect.contains(worldPos);
}
if (hitSelected) {
clearCameraSelection();
m_draggingEntity = true;
m_dragMode = DragMode::Free;
emit entityDragActiveChanged(true);
@@ -2011,6 +2170,7 @@ void EditorCanvas::mousePressEvent(QMouseEvent* e) {
const int hit = hitTestEntity(worldPos);
if (hit >= 0) {
clearCameraSelection();
m_selectedEntity = hit;
m_selectedTool = -1;
m_draggingTool = false;
@@ -2047,6 +2207,7 @@ void EditorCanvas::mousePressEvent(QMouseEvent* e) {
m_selectedTool = -1;
m_draggingTool = false;
m_dragMode = DragMode::None;
clearCameraSelection();
emit selectedEntityChanged(false, QString(), 0, QPointF());
emit selectedToolChanged(false, QString(), QPointF());
update();
@@ -2144,6 +2305,17 @@ void EditorCanvas::mouseMoveEvent(QMouseEvent* e) {
return;
}
if (m_draggingCamera && m_selectedCameraIndex >= 0 && m_selectedCameraIndex < m_cameraOverlays.size()) {
const QPointF worldPos = viewToWorld(cur);
const QPointF newCenter = worldPos - m_cameraDragOffsetWorld;
QPointF delta = newCenter - m_cameraOverlays[m_selectedCameraIndex].centerWorld;
m_cameraOverlays[m_selectedCameraIndex].centerWorld += delta;
const auto& c = m_cameraOverlays[m_selectedCameraIndex];
emit selectedCameraChanged(true, c.id, c.centerWorld, c.viewScale);
update();
return;
}
if (m_draggingEntity && m_selectedEntity >= 0 && m_selectedEntity < m_entities.size()) {
const QPointF worldPos = viewToWorld(cur);
auto& ent = m_entities[m_selectedEntity];
@@ -2229,10 +2401,12 @@ void EditorCanvas::mouseMoveEvent(QMouseEvent* e) {
// 平移画布
if (m_tool == Tool::Move || (e->buttons() & Qt::MiddleButton) ||
(m_presentationPreviewMode && (e->buttons() & Qt::LeftButton))) {
if (m_presentationPreviewMode && m_presBgPanSession) {
m_presBgDragDist += std::abs(deltaView.x()) + std::abs(deltaView.y());
if (!(m_presentationPreviewMode && m_previewCameraViewLocked)) {
if (m_presentationPreviewMode && m_presBgPanSession) {
m_presBgDragDist += std::abs(deltaView.x()) + std::abs(deltaView.y());
}
m_pan += deltaView;
}
m_pan += deltaView;
update();
return;
}
@@ -2321,6 +2495,17 @@ void EditorCanvas::mouseReleaseEvent(QMouseEvent* e) {
}
}
if (m_draggingCamera && m_selectedCameraIndex >= 0 && m_selectedCameraIndex < m_cameraOverlays.size() &&
e->button() == Qt::LeftButton) {
const auto& cam = m_cameraOverlays[m_selectedCameraIndex];
const QPointF delta = cam.centerWorld - m_cameraDragStartCenterWorld;
if (!cam.id.isEmpty() && (!qFuzzyIsNull(delta.x()) || !qFuzzyIsNull(delta.y()))) {
emit requestMoveCamera(cam.id, delta);
} else if (!cam.id.isEmpty()) {
emit selectedCameraChanged(true, cam.id, cam.centerWorld, cam.viewScale);
}
}
m_dragging = false;
if (m_pendingDragging && e->button() == Qt::LeftButton) {
m_pendingDragging = false;
@@ -2332,6 +2517,7 @@ void EditorCanvas::mouseReleaseEvent(QMouseEvent* e) {
}
m_draggingEntity = false;
m_draggingTool = false;
m_draggingCamera = false;
m_dragPreviewActive = false;
m_dragMode = DragMode::None;
updateCursor();
@@ -2340,6 +2526,19 @@ void EditorCanvas::mouseReleaseEvent(QMouseEvent* e) {
}
void EditorCanvas::wheelEvent(QWheelEvent* e) {
if (m_presentationPreviewMode && m_previewCameraViewLocked) {
e->accept();
return;
}
if (!m_presentationPreviewMode && !m_selectedCameraId.isEmpty() && m_tool == Tool::Move) {
const qreal steps = e->angleDelta().y() / 120.0;
const qreal factor = std::pow(1.15, steps);
if (!qFuzzyCompare(factor, 1.0)) {
emit requestCameraViewScaleAdjust(m_selectedCameraId, factor);
}
e->accept();
return;
}
if (m_tool != Tool::Zoom && !(e->modifiers() & Qt::ControlModifier)) {
// 默认仍允许滚轮缩放：不强制用户切换工具
//（若你希望仅在 Zoom 工具下才缩放，可在此 return）

24
client/gui/editor/EditorCanvas.h
View File

@@ -71,6 +71,13 @@ public:
// 预览呈现：完整背景 + 全部实体（忽略显隐开关），隐藏编辑辅助元素，仅可平移/缩放查看
void setPresentationPreviewMode(bool on);
bool presentationPreviewMode() const { return m_presentationPreviewMode; }
/// 预览展示由活动摄像机驱动时禁止画布平移/滚轮缩放，避免与镜头关键帧冲突
void setPreviewCameraViewLocked(bool on);
bool previewCameraViewLocked() const { return m_previewCameraViewLocked; }
/// 将视口对齐到摄像机；viewScale 为相对参考分辨率 1600×900 的像素/世界比（见 Project::Camera）
void applyCameraViewport(const QPointF& centerWorld, double viewScale);
QPointF viewCenterWorld() const;
double viewWorldScale() const { return m_scale; }
/// 退出「点击实体放大」状态并平滑回到进入前的视图（预览模式）
void clearPresentationEntityFocus();
@@ -78,7 +85,13 @@ public:
const QVector<double>& opacities01,
const QString& projectDirAbs);
void setTools(const QVector<core::Project::Tool>& tools, const QVector<double>& opacities01);
void setCameraOverlays(const QVector<core::Project::Camera>& cameras,
const QString& selectedId,
const QSet<QString>& tempHiddenCameraIds);
void selectCameraById(const QString& id);
void clearCameraSelection();
void setTempHiddenIds(const QSet<QString>& entityIds, const QSet<QString>& toolIds);
void setTempHiddenCameraIds(const QSet<QString>& cameraIds);
void setCurrentFrame(int frame);
int currentFrame() const { return m_currentFrame; }
@@ -122,6 +135,9 @@ signals:
void requestFinalizePendingEntity(const QVector<QPointF>& polyWorld);
void requestMoveEntity(const QString& id, const QPointF& delta);
void requestMoveTool(const QString& id, const QPointF& delta);
void requestMoveCamera(const QString& id, const QPointF& delta);
void requestCameraViewScaleAdjust(const QString& id, double factor);
void selectedCameraChanged(bool hasSelection, const QString& id, const QPointF& centerWorld, double viewScale);
void requestResolveBlackholeCopy(const QString& entityId, const QPoint& sourceOffsetPx);
void entityDragActiveChanged(bool on);
void selectedEntityPreviewChanged(const QString& id, int depth, const QPointF& originWorld);
@@ -255,6 +271,14 @@ private:
QVector<Entity> m_entities;
QVector<ToolView> m_tools;
QVector<core::Project::Camera> m_cameraOverlays;
QSet<QString> m_tempHiddenCameraIds;
QString m_selectedCameraId;
int m_selectedCameraIndex = -1;
bool m_draggingCamera = false;
QPointF m_cameraDragOffsetWorld;
QPointF m_cameraDragStartCenterWorld;
bool m_previewCameraViewLocked = false;
QSet<QString> m_tempHiddenEntityIds;
QSet<QString> m_tempHiddenToolIds;
QVector<QPointF> m_strokeWorld;

277
client/gui/main_window/MainWindow.cpp
View File

@@ -15,6 +15,7 @@
#include "props/BlackholePropertySection.h"
#include "props/EntityPropertySection.h"
#include "props/ToolPropertySection.h"
#include "props/CameraPropertySection.h"
#include "timeline/TimelineWidget.h"
#include "dialogs/FrameAnimationDialog.h"
#include "dialogs/EntityIntroPopup.h"
@@ -559,7 +560,7 @@ void MainWindow::createTimelineDock() {
// 合并后的关键帧按钮：一次写入位置 + userScale
auto* btnKeyCombined = new QToolButton(bar);
setToolButtonIconOrText(btnKeyCombined, QStringLiteral("media-record"), QStringLiteral("关键帧"));
btnKeyCombined->setToolTip(QStringLiteral("在当前帧记录实体的位置与缩放关键帧"));
btnKeyCombined->setToolTip(QStringLiteral("在当前帧记录实体或摄像机的位置与缩放关键帧"));
polishCompactToolButton(btnKeyCombined, 34);
layout->addWidget(btnKeyCombined);
@@ -611,7 +612,27 @@ void MainWindow::createTimelineDock() {
toolOps.push_back(rt.opacity);
}
m_editorCanvas->setTools(tools, toolOps);
QVector<core::Project::Camera> cams;
cams.reserve(rf.cameras.size());
for (const auto& rc : rf.cameras) {
cams.push_back(rc.camera);
}
m_editorCanvas->setCameraOverlays(cams, m_selectedCameraId, m_tempHiddenCameraIds);
m_editorCanvas->setTempHiddenIds(m_tempHiddenEntityIds, m_tempHiddenToolIds);
const bool presentation = m_previewRequested && m_workspace.hasBackground();
m_editorCanvas->setPreviewCameraViewLocked(false);
if (presentation) {
const QString acid = m_workspace.project().activeCameraId();
if (!acid.isEmpty()) {
for (const auto& rc : rf.cameras) {
if (rc.camera.id == acid) {
m_editorCanvas->setPreviewCameraViewLocked(true);
m_editorCanvas->applyCameraViewport(rc.camera.centerWorld, rc.camera.viewScale);
break;
}
}
}
}
m_timelineScrubbing = false;
} else if (m_editorCanvas) {
m_editorCanvas->setCurrentFrame(m_currentFrame);
@@ -710,7 +731,9 @@ void MainWindow::createTimelineDock() {
const bool entityKeyUi = (m_workspace.isOpen() && !m_selectedEntityId.isEmpty());
const bool toolKeyUi = (m_workspace.isOpen() && m_hasSelectedTool && !m_selectedToolId.isEmpty());
actDeleteKey->setEnabled(m_workspace.isOpen() && m_timeline->hasSelectedKeyframe() && (entityKeyUi || toolKeyUi));
const bool cameraKeyUi = (m_workspace.isOpen() && m_hasSelectedCamera && !m_selectedCameraId.isEmpty());
actDeleteKey->setEnabled(m_workspace.isOpen() && m_timeline->hasSelectedKeyframe() &&
(entityKeyUi || toolKeyUi || cameraKeyUi));
const int selA = m_timeline->selectionStart();
const int selB = m_timeline->selectionEnd();
const bool hasRange = (selA >= 0 && selB >= 0);
@@ -734,10 +757,18 @@ void MainWindow::createTimelineDock() {
bool ok = false;
switch (m_timeline->selectedKeyKind()) {
case TimelineWidget::KeyKind::Location:
if (!m_selectedEntityId.isEmpty()) ok = m_workspace.removeEntityLocationKey(m_selectedEntityId, f);
if (!m_selectedEntityId.isEmpty()) {
ok = m_workspace.removeEntityLocationKey(m_selectedEntityId, f);
} else if (m_hasSelectedCamera && !m_selectedCameraId.isEmpty()) {
ok = m_workspace.removeCameraLocationKey(m_selectedCameraId, f);
}
break;
case TimelineWidget::KeyKind::UserScale:
if (!m_selectedEntityId.isEmpty()) ok = m_workspace.removeEntityUserScaleKey(m_selectedEntityId, f);
if (!m_selectedEntityId.isEmpty()) {
ok = m_workspace.removeEntityUserScaleKey(m_selectedEntityId, f);
} else if (m_hasSelectedCamera && !m_selectedCameraId.isEmpty()) {
ok = m_workspace.removeCameraScaleKey(m_selectedCameraId, f);
}
break;
case TimelineWidget::KeyKind::Image:
if (!m_selectedEntityId.isEmpty()) ok = m_workspace.removeEntityImageFrame(m_selectedEntityId, f);
@@ -1007,16 +1038,33 @@ void MainWindow::syncPreviewPlaybackBar() {
}
void MainWindow::onInsertCombinedKey() {
if (m_selectedEntityId.isEmpty() || !m_editorCanvas) {
if (!m_editorCanvas || !m_workspace.isOpen()) {
return;
}
const int lf = m_currentFrame % core::Project::kClipFixedFrames;
if (m_hasSelectedCamera && !m_selectedCameraId.isEmpty()) {
const core::eval::ResolvedProjectFrame rf =
core::eval::evaluateAtFrame(m_workspace.project(), m_currentFrame, 10);
for (const auto& rc : rf.cameras) {
if (rc.camera.id == m_selectedCameraId) {
m_workspace.setCameraLocationKey(m_selectedCameraId, lf, rc.camera.centerWorld);
m_workspace.setCameraScaleKey(m_selectedCameraId, lf, rc.camera.viewScale);
refreshEditorPage();
return;
}
}
return;
}
if (m_selectedEntityId.isEmpty()) {
return;
}
// 位置关键帧：使用当前帧下的动画原点
const QPointF o = m_editorCanvas->selectedAnimatedOriginWorld();
m_workspace.setEntityLocationKey(m_selectedEntityId, m_currentFrame % core::Project::kClipFixedFrames, o);
m_workspace.setEntityLocationKey(m_selectedEntityId, lf, o);
// 缩放关键帧：使用当前帧下的 userScale（而非 depthScale01）
const double s = m_editorCanvas->selectedUserScale();
m_workspace.setEntityUserScaleKey(m_selectedEntityId, m_currentFrame % core::Project::kClipFixedFrames, s);
m_workspace.setEntityUserScaleKey(m_selectedEntityId, lf, s);
refreshEditorPage();
}
@@ -1380,6 +1428,7 @@ void MainWindow::createProjectTreeDock() {
m_bgPropertySection = new gui::BackgroundPropertySection();
m_blackholePropertySection = new gui::BlackholePropertySection();
m_entityPropertySection = new gui::EntityPropertySection();
m_cameraPropertySection = new gui::CameraPropertySection();
m_toolPropertySection = new gui::ToolPropertySection();
m_propertyStack = new QStackedWidget();
m_propertyStack->setContentsMargins(4, 4, 4, 4);
@@ -1387,6 +1436,7 @@ void MainWindow::createProjectTreeDock() {
m_propertyStack->addWidget(m_bgPropertySection);
m_propertyStack->addWidget(m_blackholePropertySection);
m_propertyStack->addWidget(m_entityPropertySection);
m_propertyStack->addWidget(m_cameraPropertySection);
m_propertyStack->addWidget(m_toolPropertySection);
connect(m_bgPropertySection, &gui::BackgroundPropertySection::backgroundVisibleToggled, this, [this](bool on) {
@@ -1600,6 +1650,37 @@ void MainWindow::createProjectTreeDock() {
refreshEditorPage();
});
connect(m_cameraPropertySection, &gui::CameraPropertySection::displayNameCommitted, this, [this](const QString& text) {
if (m_selectedCameraId.isEmpty() || !m_workspace.isOpen()) return;
if (!m_workspace.setCameraDisplayName(m_selectedCameraId, text)) return;
refreshProjectTree();
refreshPropertyPanel();
});
connect(m_cameraPropertySection, &gui::CameraPropertySection::centerEdited, this, [this](double x, double y) {
if (m_selectedCameraId.isEmpty() || !m_workspace.isOpen()) return;
if (!m_workspace.setCameraCenterWorld(m_selectedCameraId, QPointF(x, y))) return;
refreshEditorPage();
});
connect(m_cameraPropertySection, &gui::CameraPropertySection::viewScaleEdited, this, [this](double vs) {
if (m_selectedCameraId.isEmpty() || !m_workspace.isOpen()) return;
const int f = std::clamp(m_currentFrame, 0, core::Project::kClipFixedFrames - 1);
if (!m_workspace.setCameraViewScaleValue(m_selectedCameraId, vs, f)) return;
refreshEditorPage();
refreshDopeSheet();
});
connect(m_cameraPropertySection, &gui::CameraPropertySection::activePreviewToggled, this, [this](bool on) {
if (m_selectedCameraId.isEmpty() || !m_workspace.isOpen()) return;
if (on) {
if (!m_workspace.setActiveCameraId(m_selectedCameraId)) return;
} else {
if (m_workspace.project().activeCameraId() == m_selectedCameraId) {
if (!m_workspace.setActiveCameraId(QString())) return;
}
}
refreshEditorPage();
refreshPropertyPanel();
});
auto* propScroll = new SpinFriendlyScrollArea(m_dockProperties);
propScroll->setWidgetResizable(true);
propScroll->setFrameShape(QFrame::NoFrame);
@@ -1652,7 +1733,7 @@ void MainWindow::createProjectTreeDock() {
void MainWindow::refreshPropertyPanel() {
if (!m_bgPropertySection || !m_blackholePropertySection || !m_entityPropertySection ||
!m_toolPropertySection || !m_propertyStack) {
!m_cameraPropertySection || !m_toolPropertySection || !m_propertyStack) {
return;
}
@@ -1735,8 +1816,31 @@ void MainWindow::refreshPropertyPanel() {
return cur;
};
const bool cameraUi = m_hasSelectedCamera && m_workspace.isOpen() && !m_selectedCameraId.isEmpty();
if (cameraUi) {
m_entityPropertySection->clearDisconnected();
m_toolPropertySection->clearDisconnected();
gui::CameraPropertyUiState st;
const auto rf = core::eval::evaluateAtFrame(m_workspace.project(), m_currentFrame, 10);
for (const auto& rc : rf.cameras) {
if (rc.camera.id != m_selectedCameraId) {
continue;
}
st.displayName = rc.camera.displayName.isEmpty() ? rc.camera.id : rc.camera.displayName;
st.centerWorld = rc.camera.centerWorld;
st.viewScale = rc.camera.viewScale;
st.isActivePreviewCamera = (m_workspace.project().activeCameraId() == m_selectedCameraId);
break;
}
m_cameraPropertySection->applyState(st);
m_propertyStack->setCurrentWidget(m_cameraPropertySection);
m_dockProperties->setWindowTitle(QStringLiteral("属性 — 摄像机"));
return;
}
const bool toolUi = m_hasSelectedTool && m_workspace.isOpen() && !m_selectedToolId.isEmpty();
if (toolUi) {
m_cameraPropertySection->clearDisconnected();
gui::ToolPropertyUiState st;
const int f = std::clamp(m_currentFrame, 0, core::Project::kClipFixedFrames - 1);
const auto* clip = activeClipForUi();
@@ -1796,6 +1900,7 @@ void MainWindow::refreshPropertyPanel() {
const bool holeUi = m_workspace.isOpen() && !m_selectedBlackholeEntityId.isEmpty();
if (holeUi) {
m_cameraPropertySection->clearDisconnected();
gui::BlackholePropertyUiState st;
for (const auto& e : m_workspace.entities()) {
if (e.id != m_selectedBlackholeEntityId) {
@@ -1826,11 +1931,13 @@ void MainWindow::refreshPropertyPanel() {
if (!entUi) {
m_entityPropertySection->clearDisconnected();
m_toolPropertySection->clearDisconnected();
m_cameraPropertySection->clearDisconnected();
m_propertyStack->setCurrentWidget(m_bgPropertySection);
m_dockProperties->setWindowTitle(QStringLiteral("属性 — 背景"));
return;
}
m_cameraPropertySection->clearDisconnected();
QString displayName;
double userScale = 1.0;
bool ignoreDist = false;
@@ -2147,6 +2254,28 @@ void MainWindow::refreshProjectTree() {
};
addSubtree(QString(), nullptr);
if (m_workspace.isOpen()) {
for (const auto& c : m_workspace.cameras()) {
auto* it = new QTreeWidgetItem(m_projectTree);
it->setText(1, c.displayName.isEmpty() ? QStringLiteral("摄像机") : c.displayName);
it->setTextAlignment(1, Qt::AlignRight | Qt::AlignVCenter);
it->setData(0, Qt::UserRole, QStringLiteral("camera"));
it->setData(0, Qt::UserRole + 1, c.id);
it->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
auto* eye = makeEye(!m_tempHiddenCameraIds.contains(c.id), true);
m_projectTree->setItemWidget(it, 0, eye);
connect(eye, &QToolButton::toggled, this, [this, id = c.id](bool on) {
if (!m_workspace.isOpen()) return;
if (on) m_tempHiddenCameraIds.remove(id);
else m_tempHiddenCameraIds.insert(id);
if (m_editorCanvas) {
m_editorCanvas->setTempHiddenCameraIds(m_tempHiddenCameraIds);
}
});
}
}
m_projectTree->expandAll();
if (m_projectTree->header()) {
@@ -2165,6 +2294,7 @@ void MainWindow::syncProjectTreeFromCanvasSelection() {
m_projectTree->blockSignals(true);
if ((!m_hasSelectedEntity || m_selectedEntityId.isEmpty()) &&
(!m_hasSelectedTool || m_selectedToolId.isEmpty()) &&
(!m_hasSelectedCamera || m_selectedCameraId.isEmpty()) &&
m_selectedBlackholeEntityId.isEmpty()) {
m_projectTree->clearSelection();
} else {
@@ -2181,6 +2311,11 @@ void MainWindow::syncProjectTreeFromCanvasSelection() {
found = node;
break;
}
if (m_hasSelectedCamera && !m_selectedCameraId.isEmpty() && kind == QStringLiteral("camera") &&
id == m_selectedCameraId) {
found = node;
break;
}
if (!m_selectedBlackholeEntityId.isEmpty() && kind == QStringLiteral("blackhole") &&
id == m_selectedBlackholeEntityId) {
found = node;
@@ -2213,9 +2348,14 @@ void MainWindow::onProjectTreeItemClicked(QTreeWidgetItem* item, int column) {
}
m_hasSelectedTool = false;
m_selectedToolId.clear();
m_hasSelectedCamera = false;
m_selectedCameraId.clear();
if (m_timeline) {
m_timeline->setToolKeyframeTracks({}, {});
}
if (m_editorCanvas) {
m_editorCanvas->clearCameraSelection();
}
m_editorCanvas->selectEntityById(id);
}
} else if (kind == QStringLiteral("tool")) {
@@ -2229,8 +2369,33 @@ void MainWindow::onProjectTreeItemClicked(QTreeWidgetItem* item, int column) {
m_selectedToolId = id;
m_hasSelectedEntity = false;
m_selectedEntityId.clear();
m_hasSelectedCamera = false;
m_selectedCameraId.clear();
if (m_editorCanvas) {
m_editorCanvas->clearEntitySelection();
m_editorCanvas->clearCameraSelection();
}
if (m_timeline) {
updateTimelineTracks();
}
refreshPropertyPanel();
}
} else if (kind == QStringLiteral("camera")) {
const QString id = item->data(0, Qt::UserRole + 1).toString();
if (!id.isEmpty()) {
m_selectedBlackholeEntityId.clear();
if (m_editorCanvas) {
m_editorCanvas->clearBlackholeSelection();
}
m_hasSelectedTool = false;
m_selectedToolId.clear();
m_hasSelectedEntity = false;
m_selectedEntityId.clear();
m_hasSelectedCamera = true;
m_selectedCameraId = id;
if (m_editorCanvas) {
m_editorCanvas->clearEntitySelection();
m_editorCanvas->selectCameraById(id);
}
if (m_timeline) {
updateTimelineTracks();
@@ -2246,8 +2411,11 @@ void MainWindow::onProjectTreeItemClicked(QTreeWidgetItem* item, int column) {
m_hasSelectedEntity = false;
m_selectedEntityId.clear();
m_selectedEntityDisplayNameCache.clear();
m_hasSelectedCamera = false;
m_selectedCameraId.clear();
if (m_editorCanvas) {
m_editorCanvas->clearEntitySelection();
m_editorCanvas->clearCameraSelection();
m_editorCanvas->selectBlackholeByEntityId(entityId);
}
updateTimelineTracks();
@@ -2257,8 +2425,11 @@ void MainWindow::onProjectTreeItemClicked(QTreeWidgetItem* item, int column) {
m_selectedBlackholeEntityId.clear();
m_hasSelectedTool = false;
m_selectedToolId.clear();
m_hasSelectedCamera = false;
m_selectedCameraId.clear();
m_editorCanvas->clearEntitySelection();
m_editorCanvas->clearBlackholeSelection();
m_editorCanvas->clearCameraSelection();
updateTimelineTracks();
}
}
@@ -2751,6 +2922,8 @@ void MainWindow::rebuildCentralPages() {
m_selectedEntityOrigin = origin;
m_hasSelectedTool = false;
m_selectedToolId.clear();
m_hasSelectedCamera = false;
m_selectedCameraId.clear();
if (hasSel && !id.isEmpty()) {
for (const auto& e : m_workspace.entities()) {
if (e.id == id) {
@@ -2776,6 +2949,8 @@ void MainWindow::rebuildCentralPages() {
m_hasSelectedEntity = false;
m_selectedEntityId.clear();
m_selectedEntityDisplayNameCache.clear();
m_hasSelectedCamera = false;
m_selectedCameraId.clear();
}
updateTimelineTracks();
if (!m_timelineScrubbing) {
@@ -3176,6 +3351,50 @@ void MainWindow::rebuildCentralPages() {
refreshProjectTree();
updateUiEnabledState();
});
connect(m_editorCanvas, &EditorCanvas::requestMoveCamera, this, [this](const QString& id, const QPointF& delta) {
const bool autoKey = true;
if (!m_workspace.moveCameraBy(id, delta, m_currentFrame % core::Project::kClipFixedFrames, autoKey)) {
return;
}
refreshEditorPage();
refreshProjectTree();
updateUiEnabledState();
});
connect(m_editorCanvas, &EditorCanvas::requestCameraViewScaleAdjust, this, [this](const QString& id, double factor) {
if (id.isEmpty() || !m_workspace.isOpen()) return;
const core::eval::ResolvedProjectFrame resFrame =
core::eval::evaluateAtFrame(m_workspace.project(), m_currentFrame, 10);
for (const auto& rc : resFrame.cameras) {
if (rc.camera.id != id) continue;
const double ns = std::clamp(rc.camera.viewScale * factor, 1e-6, 1e3);
const int kf = std::clamp(m_currentFrame, 0, core::Project::kClipFixedFrames - 1);
if (!m_workspace.setCameraViewScaleValue(id, ns, kf)) return;
refreshEditorPage();
refreshDopeSheet();
return;
}
});
connect(m_editorCanvas, &EditorCanvas::selectedCameraChanged, this,
[this](bool hasSel, const QString& id, const QPointF& centerWorld, double viewScale) {
Q_UNUSED(centerWorld);
Q_UNUSED(viewScale);
m_hasSelectedCamera = hasSel;
m_selectedCameraId = id;
if (hasSel) {
m_hasSelectedEntity = false;
m_selectedEntityId.clear();
m_selectedEntityDisplayNameCache.clear();
m_hasSelectedTool = false;
m_selectedToolId.clear();
m_selectedBlackholeEntityId.clear();
}
updateTimelineTracks();
if (!m_timelineScrubbing) {
updateStatusBarText();
refreshPropertyPanel();
syncProjectTreeFromCanvasSelection();
}
});
connect(m_editorCanvas, &EditorCanvas::requestResolveBlackholeCopy, this,
[this](const QString& entityId, const QPoint& sourceOffsetPx) {
if (!m_workspace.resolveBlackholeByCopyBackground(entityId, sourceOffsetPx, true)) {
@@ -3406,12 +3625,32 @@ void MainWindow::refreshEditorPage() {
opacities.push_back(rt.opacity);
}
m_editorCanvas->setTools(tools, opacities);
QVector<core::Project::Camera> cams;
cams.reserve(rf.cameras.size());
for (const auto& rc : rf.cameras) {
cams.push_back(rc.camera);
}
m_editorCanvas->setCameraOverlays(cams, m_selectedCameraId, m_tempHiddenCameraIds);
m_editorCanvas->setCurrentFrame(m_currentFrame);
m_editorCanvas->setTempHiddenIds(m_tempHiddenEntityIds, m_tempHiddenToolIds);
m_editorCanvas->setPreviewCameraViewLocked(false);
if (presentation) {
const QString acid = m_workspace.project().activeCameraId();
if (!acid.isEmpty()) {
for (const auto& rc : rf.cameras) {
if (rc.camera.id == acid) {
m_editorCanvas->setPreviewCameraViewLocked(true);
m_editorCanvas->applyCameraViewport(rc.camera.centerWorld, rc.camera.viewScale);
break;
}
}
}
}
updateTimelineTracks();
} else {
m_editorCanvas->setEntities({}, {}, QString());
m_editorCanvas->setCameraOverlays({}, QString(), {});
if (m_timeline) {
m_timeline->setKeyframeTracks({}, {}, {}, {});
m_timeline->setToolKeyframeTracks({}, {});
@@ -3438,11 +3677,13 @@ void MainWindow::updateTimelineTracks() {
const bool wantEntity = !m_selectedEntityId.isEmpty();
const bool wantTool = (m_hasSelectedTool && !m_selectedToolId.isEmpty());
const bool wantCamera = (m_hasSelectedCamera && !m_selectedCameraId.isEmpty());
// 未选中时不显示关键帧（按需求）
if (!wantEntity) m_timeline->setKeyframeTracks({}, {}, {}, {});
if (!wantTool) m_timeline->setToolKeyframeTracks({}, {});
if (!wantEntity && !wantTool) return;
if (!wantEntity && !wantTool && !wantCamera) {
m_timeline->setKeyframeTracks({}, {}, {}, {});
m_timeline->setToolKeyframeTracks({}, {});
return;
}
// 选择当前 clip（与 workspace 写入规则一致）
const core::Project::AnimationClip* clip = nullptr;
@@ -3513,7 +3754,16 @@ void MainWindow::updateTimelineTracks() {
const auto im = clip->entityImageFrames.value(m_selectedEntityId);
const auto vis = clip->entityVisibilityKeys.value(m_selectedEntityId);
m_timeline->setKeyframeTracks(framesOfVec2(loc), framesOfDouble(sc), framesOfImage(im), framesOfBool(vis));
} else if (wantCamera) {
const auto loc = clip->cameraLocationKeys.value(m_selectedCameraId);
const auto sc = clip->cameraScaleKeys.value(m_selectedCameraId);
m_timeline->setKeyframeTracks(framesOfVec2(loc), framesOfDouble(sc), {}, {});
} else {
m_timeline->setKeyframeTracks({}, {}, {}, {});
}
// 注意：未选中工具时不能调用 setToolKeyframeTracks({}, {})，其实现会清空 m_locFrames/m_scaleFrames，
// 从而冲掉上面已为实体/摄像机写入的轨道数据。
if (wantTool) {
const auto loc = clip->toolLocationKeys.value(m_selectedToolId);
const auto vis = clip->toolVisibilityKeys.value(m_selectedToolId);
@@ -4082,6 +4332,9 @@ void MainWindow::onCloseProject() {
m_selectedEntityDepth = 0;
m_selectedEntityOrigin = QPointF();
m_selectedEntityId.clear();
m_hasSelectedCamera = false;
m_selectedCameraId.clear();
m_tempHiddenCameraIds.clear();
m_currentFrame = 0;
statusBar()->showMessage(QStringLiteral("工程已关闭"));

5
client/gui/main_window/MainWindow.h
View File

@@ -37,6 +37,7 @@ class BackgroundPropertySection;
class BlackholePropertySection;
class EntityPropertySection;
class ToolPropertySection;
class CameraPropertySection;
class EntityIntroPopup;
class ResourceLibraryDock;
}
@@ -130,6 +131,7 @@ private:
gui::BlackholePropertySection* m_blackholePropertySection = nullptr;
gui::EntityPropertySection* m_entityPropertySection = nullptr;
gui::ToolPropertySection* m_toolPropertySection = nullptr;
gui::CameraPropertySection* m_cameraPropertySection = nullptr;
QToolButton* m_btnCreateEntity = nullptr;
ToolOptionPopup* m_createEntityPopup = nullptr;
QToolButton* m_btnToggleDepthOverlay = nullptr;
@@ -170,11 +172,13 @@ private:
int m_lastWorldZ = -1;
bool m_hasSelectedEntity = false;
bool m_hasSelectedTool = false;
bool m_hasSelectedCamera = false;
bool m_syncingTreeSelection = false;
int m_selectedEntityDepth = 0;
QPointF m_selectedEntityOrigin;
QString m_selectedEntityId;
QString m_selectedToolId;
QString m_selectedCameraId;
QString m_selectedBlackholeEntityId;
QString m_selectedEntityDisplayNameCache;
QString m_bgAbsCache;
@@ -182,6 +186,7 @@ private:
// 项目树“眼睛”：仅用于画布临时隐藏（不持久化、不进时间轴）
QSet<QString> m_tempHiddenEntityIds;
QSet<QString> m_tempHiddenToolIds;
QSet<QString> m_tempHiddenCameraIds;
void updateStatusBarText();
void syncCreateEntityToolButtonTooltip();
void refreshPropertyPanel();

111
client/gui/props/CameraPropertySection.cpp Normal file
View File

@@ -0,0 +1,111 @@
#include "props/CameraPropertySection.h"
#include "params/ParamControls.h"
#include <QCheckBox>
#include <QDoubleSpinBox>
#include <QFormLayout>
#include <QLabel>
#include <QLineEdit>
#include <QVBoxLayout>
namespace gui {
CameraPropertySection::CameraPropertySection(QWidget* parent) : PropertySectionWidget(parent) {
auto* lay = new QVBoxLayout(this);
lay->setContentsMargins(0, 0, 0, 0);
lay->setSpacing(6);
auto* form = new QFormLayout();
form->setContentsMargins(0, 0, 0, 0);
form->setSpacing(6);
m_name = new QLineEdit(this);
m_name->setPlaceholderText(QStringLiteral("显示名称…"));
form->addRow(QStringLiteral("名称"), m_name);
m_center = new Vec2ParamControl(this);
m_center->setToolTip(QStringLiteral("摄像机中心（世界坐标），与画布上黄色圆点一致"));
form->addRow(QStringLiteral("中心"), m_center);
m_viewScale = new QDoubleSpinBox(this);
m_viewScale->setRange(1e-4, 1000.0);
m_viewScale->setDecimals(5);
m_viewScale->setSingleStep(0.01);
m_viewScale->setToolTip(QStringLiteral(
"视口缩放：在参考分辨率 1600×900 下的像素/世界单位比（与预览、画布上镜头框一致）；"
"不随当前窗口大小改变镜头覆盖的世界范围。数值越小，可见的世界范围越大。"));
form->addRow(QStringLiteral("缩放"), m_viewScale);
m_activePreview = new QCheckBox(QStringLiteral("用作预览展示镜头"), this);
m_activePreview->setToolTip(QStringLiteral("进入预览展示时，按该摄像机在当前帧的位置与缩放呈现画面"));
form->addRow(QStringLiteral("预览"), m_activePreview);
lay->addLayout(form);
lay->addStretch(1);
connect(m_name, &QLineEdit::editingFinished, this, [this]() {
if (m_name) emit displayNameCommitted(m_name->text());
});
connect(m_center, &Vec2ParamControl::valueChanged, this, [this](double x, double y) { emit centerEdited(x, y); });
connect(m_viewScale, qOverload<double>(&QDoubleSpinBox::valueChanged), this,
&CameraPropertySection::viewScaleEdited);
connect(m_activePreview, &QCheckBox::toggled, this, &CameraPropertySection::activePreviewToggled);
}
void CameraPropertySection::setEditingEnabled(bool on) {
for (auto* w : {static_cast<QWidget*>(m_name), static_cast<QWidget*>(m_center), static_cast<QWidget*>(m_viewScale),
static_cast<QWidget*>(m_activePreview)}) {
if (w) w->setEnabled(on);
}
}
void CameraPropertySection::clearDisconnected() {
setEditingEnabled(false);
if (m_name) {
m_name->blockSignals(true);
m_name->clear();
m_name->blockSignals(false);
}
if (m_center) {
m_center->blockSignals(true);
m_center->setValue(0.0, 0.0);
m_center->blockSignals(false);
}
if (m_viewScale) {
m_viewScale->blockSignals(true);
m_viewScale->setValue(1.0);
m_viewScale->blockSignals(false);
}
if (m_activePreview) {
m_activePreview->blockSignals(true);
m_activePreview->setChecked(false);
m_activePreview->blockSignals(false);
}
}
void CameraPropertySection::applyState(const CameraPropertyUiState& s) {
setEditingEnabled(true);
if (m_name) {
m_name->blockSignals(true);
m_name->setText(s.displayName);
m_name->blockSignals(false);
}
if (m_center) {
m_center->blockSignals(true);
m_center->setValue(s.centerWorld.x(), s.centerWorld.y());
m_center->blockSignals(false);
}
if (m_viewScale) {
m_viewScale->blockSignals(true);
m_viewScale->setValue(s.viewScale);
m_viewScale->blockSignals(false);
}
if (m_activePreview) {
m_activePreview->blockSignals(true);
m_activePreview->setChecked(s.isActivePreviewCamera);
m_activePreview->blockSignals(false);
}
}
} // namespace gui

47
client/gui/props/CameraPropertySection.h Normal file
View File

@@ -0,0 +1,47 @@
#pragma once
#include "props/PropertySectionWidget.h"
#include <QPointF>
#include <QString>
class QCheckBox;
class QDoubleSpinBox;
class QLineEdit;
namespace gui {
class Vec2ParamControl;
}
namespace gui {
struct CameraPropertyUiState {
QString displayName;
QPointF centerWorld;
double viewScale = 1.0;
bool isActivePreviewCamera = false;
};
class CameraPropertySection final : public PropertySectionWidget {
Q_OBJECT
public:
explicit CameraPropertySection(QWidget* parent = nullptr);
void clearDisconnected();
void applyState(const CameraPropertyUiState& s);
void setEditingEnabled(bool on);
signals:
void displayNameCommitted(const QString& text);
void centerEdited(double x, double y);
void viewScaleEdited(double viewScale);
void activePreviewToggled(bool on);
private:
QLineEdit* m_name = nullptr;
Vec2ParamControl* m_center = nullptr;
QDoubleSpinBox* m_viewScale = nullptr;
QCheckBox* m_activePreview = nullptr;
};
} // namespace gui