1693 lines
62 KiB
C++
1693 lines
62 KiB
C++
#include "editor/EditorCanvas.h"
|
||
#include "editor/EntityCutoutUtils.h"
|
||
|
||
#include "core/animation/AnimationSampling.h"
|
||
#include "core/depth/DepthService.h"
|
||
|
||
#include <algorithm>
|
||
#include <cmath>
|
||
#include <QBuffer>
|
||
#include <QDir>
|
||
#include <QFileInfo>
|
||
#include <QCursor>
|
||
#include <QMouseEvent>
|
||
#include <QPainter>
|
||
#include <QPaintEvent>
|
||
#include <QPainterPath>
|
||
#include <QWheelEvent>
|
||
#include <QKeyEvent>
|
||
#include <QJsonArray>
|
||
#include <QIODevice>
|
||
#include <QPen>
|
||
#include <QPolygonF>
|
||
|
||
namespace {
|
||
|
||
constexpr int kSamCropMargin = 32;
|
||
constexpr int kMinStrokePointsSam = 4;
|
||
constexpr int kMinStrokePointsManual = 8;
|
||
constexpr int kMaxSamPointPrompts = 32;
|
||
|
||
QVector<QPointF> snapStrokeToEdges(const QVector<QPointF>& strokeWorld, const QImage& bgImage, int searchRadiusPx) {
|
||
if (strokeWorld.size() < 3 || bgImage.isNull()) {
|
||
return strokeWorld;
|
||
}
|
||
QImage gray = bgImage.convertToFormat(QImage::Format_Grayscale8);
|
||
const int w = gray.width();
|
||
const int h = gray.height();
|
||
auto at = [&](int x, int y) -> int {
|
||
x = std::clamp(x, 0, w - 1);
|
||
y = std::clamp(y, 0, h - 1);
|
||
return static_cast<int>(static_cast<const uchar*>(gray.constScanLine(y))[x]);
|
||
};
|
||
auto gradMag = [&](int x, int y) -> int {
|
||
// 简易 Sobel 近似（整数）
|
||
const int gx =
|
||
-at(x - 1, y - 1) + at(x + 1, y - 1) +
|
||
-2 * at(x - 1, y) + 2 * at(x + 1, y) +
|
||
-at(x - 1, y + 1) + at(x + 1, y + 1);
|
||
const int gy =
|
||
-at(x - 1, y - 1) - 2 * at(x, y - 1) - at(x + 1, y - 1) +
|
||
at(x - 1, y + 1) + 2 * at(x, y + 1) + at(x + 1, y + 1);
|
||
return std::abs(gx) + std::abs(gy);
|
||
};
|
||
QVector<QPointF> out;
|
||
out.reserve(strokeWorld.size());
|
||
const int r = std::max(1, searchRadiusPx);
|
||
for (const QPointF& p : strokeWorld) {
|
||
const int cx = static_cast<int>(std::round(p.x()));
|
||
const int cy = static_cast<int>(std::round(p.y()));
|
||
int bestX = cx;
|
||
int bestY = cy;
|
||
int bestG = -1;
|
||
for (int dy = -r; dy <= r; ++dy) {
|
||
for (int dx = -r; dx <= r; ++dx) {
|
||
const int x = cx + dx;
|
||
const int y = cy + dy;
|
||
if (x < 0 || y < 0 || x >= w || y >= h) continue;
|
||
const int g = gradMag(x, y);
|
||
if (g > bestG) {
|
||
bestG = g;
|
||
bestX = x;
|
||
bestY = y;
|
||
}
|
||
}
|
||
}
|
||
out.push_back(QPointF(bestX, bestY));
|
||
}
|
||
return out;
|
||
}
|
||
|
||
bool buildSamSegmentPayloadFromStroke(
|
||
const QVector<QPointF>& strokeWorld,
|
||
const QImage& bgImage,
|
||
QByteArray& outCropPng,
|
||
QByteArray& outOverlayPng,
|
||
QPointF& outCropTopLeftWorld,
|
||
QJsonArray& outPointCoords,
|
||
QJsonArray& outPointLabels,
|
||
QJsonArray& outBoxXyxy
|
||
) {
|
||
if (strokeWorld.size() < kMinStrokePointsSam || bgImage.isNull()) {
|
||
return false;
|
||
}
|
||
const QRectF polyBr = QPolygonF(strokeWorld).boundingRect();
|
||
if (polyBr.isEmpty()) {
|
||
return false;
|
||
}
|
||
const QRect cropRect = entity_cutout::clampRectToImage(
|
||
polyBr.adjusted(-kSamCropMargin, -kSamCropMargin, kSamCropMargin, kSamCropMargin).toAlignedRect(),
|
||
bgImage.size());
|
||
if (cropRect.isEmpty()) {
|
||
return false;
|
||
}
|
||
outCropTopLeftWorld = cropRect.topLeft();
|
||
|
||
const QImage cropRgb = bgImage.copy(cropRect).convertToFormat(QImage::Format_RGB888);
|
||
QBuffer bufCrop(&outCropPng);
|
||
if (!bufCrop.open(QIODevice::WriteOnly) || !cropRgb.save(&bufCrop, "PNG")) {
|
||
outCropPng.clear();
|
||
return false;
|
||
}
|
||
bufCrop.close();
|
||
|
||
const QPointF origin = cropRect.topLeft();
|
||
const int cw = cropRect.width();
|
||
const int ch = cropRect.height();
|
||
|
||
QImage overlay(cw, ch, QImage::Format_ARGB32_Premultiplied);
|
||
overlay.fill(Qt::transparent);
|
||
{
|
||
QPainter pop(&overlay);
|
||
pop.setRenderHint(QPainter::Antialiasing, true);
|
||
QPen pen(QColor(255, 60, 60, 240));
|
||
pen.setWidthF(4.0);
|
||
pen.setCapStyle(Qt::RoundCap);
|
||
pen.setJoinStyle(Qt::RoundJoin);
|
||
pop.setPen(pen);
|
||
QPolygonF local;
|
||
local.reserve(strokeWorld.size());
|
||
for (const QPointF& w : strokeWorld) {
|
||
local.append(w - origin);
|
||
}
|
||
pop.drawPolyline(local);
|
||
}
|
||
QBuffer bufOv(&outOverlayPng);
|
||
if (!bufOv.open(QIODevice::WriteOnly) || !overlay.save(&bufOv, "PNG")) {
|
||
outOverlayPng.clear();
|
||
return false;
|
||
}
|
||
bufOv.close();
|
||
|
||
const int n = static_cast<int>(strokeWorld.size());
|
||
const int step = std::max(1, (n + kMaxSamPointPrompts - 1) / kMaxSamPointPrompts);
|
||
for (int i = 0; i < n; i += step) {
|
||
const QPointF L = strokeWorld[i] - origin;
|
||
outPointCoords.append(QJsonArray{L.x(), L.y()});
|
||
outPointLabels.append(1);
|
||
}
|
||
if (n > 1) {
|
||
const QPointF Llast = strokeWorld.last() - origin;
|
||
if (!outPointCoords.isEmpty()) {
|
||
const QJsonArray prev = outPointCoords.last().toArray();
|
||
if (prev.size() >= 2) {
|
||
const double dx = Llast.x() - prev.at(0).toDouble();
|
||
const double dy = Llast.y() - prev.at(1).toDouble();
|
||
if (dx * dx + dy * dy > 4.0) {
|
||
outPointCoords.append(QJsonArray{Llast.x(), Llast.y()});
|
||
outPointLabels.append(1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
const QRectF tight = QPolygonF(strokeWorld).boundingRect();
|
||
auto clampD = [](double v, double lo, double hi) { return std::clamp(v, lo, hi); };
|
||
double x1 = clampD(tight.left() - origin.x(), 0.0, static_cast<double>(cw - 1));
|
||
double y1 = clampD(tight.top() - origin.y(), 0.0, static_cast<double>(ch - 1));
|
||
double x2 = clampD(tight.right() - origin.x(), 0.0, static_cast<double>(cw - 1));
|
||
double y2 = clampD(tight.bottom() - origin.y(), 0.0, static_cast<double>(ch - 1));
|
||
if (x2 <= x1) {
|
||
x2 = std::min(static_cast<double>(cw - 1), x1 + 1.0);
|
||
}
|
||
if (y2 <= y1) {
|
||
y2 = std::min(static_cast<double>(ch - 1), y1 + 1.0);
|
||
}
|
||
outBoxXyxy = QJsonArray{x1, y1, x2, y2};
|
||
return true;
|
||
}
|
||
|
||
void drawCheckerboard(QPainter& p, const QRect& r) {
|
||
// 轻量级棋盘格，让透明/纯色背景也有参照
|
||
const int cell = 16;
|
||
const QColor c1(245, 245, 245);
|
||
const QColor c2(230, 230, 230);
|
||
|
||
for (int y = r.top(); y < r.bottom(); y += cell) {
|
||
for (int x = r.left(); x < r.right(); x += cell) {
|
||
const bool odd = ((x / cell) + (y / cell)) % 2;
|
||
p.fillRect(QRect(x, y, cell, cell), odd ? c1 : c2);
|
||
}
|
||
}
|
||
}
|
||
|
||
void drawGrid(QPainter& p, const QRect& r) {
|
||
const int step = 64;
|
||
QPen pen(QColor(0, 0, 0, 24));
|
||
pen.setWidth(1);
|
||
p.setPen(pen);
|
||
|
||
for (int x = r.left(); x <= r.right(); x += step) {
|
||
p.drawLine(QPoint(x, r.top()), QPoint(x, r.bottom()));
|
||
}
|
||
for (int y = r.top(); y <= r.bottom(); y += step) {
|
||
p.drawLine(QPoint(r.left(), y), QPoint(r.right(), y));
|
||
}
|
||
}
|
||
|
||
QRectF transformedRectByScaleAndTranslate(const QRectF& r, const QPointF& center, double scaleRatio, const QPointF& delta) {
|
||
if (r.isNull()) {
|
||
return r.translated(delta);
|
||
}
|
||
const QPointF c = center + delta;
|
||
auto mapPt = [&](const QPointF& p) {
|
||
return c + (p + delta - c) * scaleRatio;
|
||
};
|
||
const QPointF p1 = mapPt(r.topLeft());
|
||
const QPointF p2 = mapPt(r.topRight());
|
||
const QPointF p3 = mapPt(r.bottomLeft());
|
||
const QPointF p4 = mapPt(r.bottomRight());
|
||
const qreal minX = std::min({p1.x(), p2.x(), p3.x(), p4.x()});
|
||
const qreal minY = std::min({p1.y(), p2.y(), p3.y(), p4.y()});
|
||
const qreal maxX = std::max({p1.x(), p2.x(), p3.x(), p4.x()});
|
||
const qreal maxY = std::max({p1.y(), p2.y(), p3.y(), p4.y()});
|
||
return QRectF(QPointF(minX, minY), QPointF(maxX, maxY));
|
||
}
|
||
|
||
int sampleDepthAtPoint(const QImage& depth8, const QPointF& worldPos) {
|
||
if (depth8.isNull() || depth8.format() != QImage::Format_Grayscale8) {
|
||
return 0;
|
||
}
|
||
const int xi = static_cast<int>(std::floor(worldPos.x()));
|
||
const int yi = static_cast<int>(std::floor(worldPos.y()));
|
||
if (xi < 0 || yi < 0 || xi >= depth8.width() || yi >= depth8.height()) {
|
||
return 0;
|
||
}
|
||
return static_cast<int>(depth8.constScanLine(yi)[xi]);
|
||
}
|
||
|
||
double depthToScale01(int depthZ) {
|
||
// 约定：depth=0 最远，depth=255 最近（与后端输出一致）。映射为 0..1（远->0，近->1）。
|
||
const int d = std::clamp(depthZ, 0, 255);
|
||
return static_cast<double>(d) / 255.0;
|
||
}
|
||
|
||
// depth01 0..1 -> 原始距离乘子 0.5..1.5；calibMult>0 时除以创建时记录的基准，使「原位置」为 1.0
|
||
double distanceScaleFromDepth01(double depth01, double calibMult) {
|
||
const double d = std::clamp(depth01, 0.0, 1.0);
|
||
const double raw = 0.5 + d * 1.0;
|
||
if (calibMult > 0.0) {
|
||
return raw / std::max(calibMult, 1e-6);
|
||
}
|
||
return raw;
|
||
}
|
||
|
||
struct GizmoHit {
|
||
EditorCanvas::DragMode mode = EditorCanvas::DragMode::None;
|
||
};
|
||
|
||
GizmoHit hitTestGizmo(const QPointF& mouseView, const QPointF& originView) {
|
||
// 以 view 像素为单位的手柄大小（不随缩放变化）
|
||
const qreal len = 56.0;
|
||
const qreal halfThickness = 6.0;
|
||
|
||
const QRectF xHandle(QPointF(originView.x(), originView.y() - halfThickness),
|
||
QSizeF(len, halfThickness * 2.0));
|
||
const QRectF yHandle(QPointF(originView.x() - halfThickness, originView.y()),
|
||
QSizeF(halfThickness * 2.0, len));
|
||
|
||
if (xHandle.contains(mouseView)) {
|
||
return {EditorCanvas::DragMode::AxisX};
|
||
}
|
||
if (yHandle.contains(mouseView)) {
|
||
return {EditorCanvas::DragMode::AxisY};
|
||
}
|
||
return {};
|
||
}
|
||
|
||
} // namespace
|
||
|
||
EditorCanvas::EditorCanvas(QWidget* parent)
|
||
: QWidget(parent) {
|
||
setAutoFillBackground(false);
|
||
setMinimumSize(480, 320);
|
||
setFocusPolicy(Qt::StrongFocus);
|
||
setMouseTracking(true);
|
||
|
||
m_previewEmitTimer.start();
|
||
|
||
m_presZoomTimer = new QTimer(this);
|
||
m_presZoomTimer->setInterval(16);
|
||
connect(m_presZoomTimer, &QTimer::timeout, this, &EditorCanvas::tickPresentationZoomAnimation);
|
||
|
||
m_presHoverTimer = new QTimer(this);
|
||
m_presHoverTimer->setInterval(40);
|
||
connect(m_presHoverTimer, &QTimer::timeout, this, &EditorCanvas::tickPresentationHoverAnimation);
|
||
|
||
updateCursor();
|
||
}
|
||
|
||
void EditorCanvas::setPresentationPreviewMode(bool on) {
|
||
if (m_presentationPreviewMode == on) {
|
||
return;
|
||
}
|
||
m_presentationPreviewMode = on;
|
||
if (m_presZoomTimer) {
|
||
m_presZoomTimer->stop();
|
||
}
|
||
if (m_presHoverTimer) {
|
||
m_presHoverTimer->stop();
|
||
}
|
||
m_presHoverEntityIndex = -1;
|
||
m_presFocusedEntityIndex = -1;
|
||
m_presHoverPhase = 0.0;
|
||
m_presZoomAnimT = 0.0;
|
||
m_presZoomFinishingRestore = false;
|
||
m_presBgPanSession = false;
|
||
m_presBgDragDist = 0.0;
|
||
if (on) {
|
||
m_tool = Tool::Move;
|
||
m_selectedEntity = -1;
|
||
m_draggingEntity = false;
|
||
m_drawingEntity = false;
|
||
m_dragMode = DragMode::None;
|
||
emit selectedEntityChanged(false, QString(), 0, QPointF());
|
||
}
|
||
m_bgCutoutDirty = true;
|
||
updateCursor();
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setEntities(const QVector<core::Project::Entity>& entities, const QString& projectDirAbs) {
|
||
const QString prevSelectedId =
|
||
(m_selectedEntity >= 0 && m_selectedEntity < m_entities.size()) ? m_entities[m_selectedEntity].id : QString();
|
||
|
||
m_entities.clear();
|
||
m_entities.reserve(entities.size());
|
||
|
||
// 需要用深度图来自动计算 z 与缩放（逐帧）
|
||
if (!m_depthAbsPath.isEmpty()) {
|
||
if (m_depthDirty) {
|
||
m_depthDirty = false;
|
||
QImage img(m_depthAbsPath);
|
||
m_depthImage8 = img.isNull() ? QImage() : img.convertToFormat(QImage::Format_Grayscale8);
|
||
}
|
||
}
|
||
|
||
for (const auto& e : entities) {
|
||
Entity v;
|
||
v.id = e.id;
|
||
v.hiddenInEditMode = !m_presentationPreviewMode && !e.visible;
|
||
using core::KeyInterpolation;
|
||
const QPointF originWorld =
|
||
core::sampleLocation(e.locationKeys, m_currentFrame, e.originWorld, KeyInterpolation::Linear);
|
||
v.animatedOriginWorld = originWorld;
|
||
v.cutoutPolygonWorld = e.cutoutPolygonWorld;
|
||
v.distanceScaleCalibMult = e.distanceScaleCalibMult;
|
||
|
||
// 逐帧自动算 z：使用实体多边形质心作为锚点采样深度（O(1)），避免卡顿
|
||
QVector<QPointF> polyTmp;
|
||
polyTmp.reserve(e.polygonLocal.size());
|
||
for (const auto& lp : e.polygonLocal) {
|
||
polyTmp.push_back(originWorld + lp);
|
||
}
|
||
const QPointF cTmp = polyTmp.isEmpty() ? originWorld : entity_cutout::polygonCentroid(polyTmp);
|
||
const int z = (!m_depthImage8.isNull()) ? sampleDepthAtPoint(m_depthImage8, cTmp) : e.depth;
|
||
v.depth = z;
|
||
|
||
const double ds01 = depthToScale01(z);
|
||
v.animatedDepthScale01 = ds01;
|
||
const double userScaleAnimated =
|
||
core::sampleUserScale(e.userScaleKeys, m_currentFrame, e.userScale, core::KeyInterpolation::Linear);
|
||
v.userScale = std::max(1e-6, userScaleAnimated);
|
||
const double distScale = distanceScaleFromDepth01(ds01, e.distanceScaleCalibMult);
|
||
const double scale = distScale * v.userScale;
|
||
v.visualScale = scale;
|
||
|
||
v.polygonWorld.clear();
|
||
v.polygonWorld.reserve(e.polygonLocal.size());
|
||
for (const auto& lp : e.polygonLocal) {
|
||
v.polygonWorld.push_back(originWorld + lp * scale);
|
||
}
|
||
|
||
// 贴图按 origin 缩放
|
||
v.imageTopLeft = originWorld + (e.imageTopLeftWorld - e.originWorld) * scale;
|
||
v.pathWorld = entity_cutout::pathFromWorldPolygon(v.polygonWorld);
|
||
v.rect = v.pathWorld.boundingRect();
|
||
v.color = QColor(255, 120, 0, 70);
|
||
|
||
const QString imgRel = core::sampleImagePath(e.imageFrames, m_currentFrame, e.imagePath);
|
||
if (!imgRel.isEmpty() && !projectDirAbs.isEmpty()) {
|
||
const QString abs = QDir(projectDirAbs).filePath(imgRel);
|
||
if (QFileInfo::exists(abs)) {
|
||
QImage img(abs);
|
||
if (!img.isNull() && img.format() != QImage::Format_ARGB32_Premultiplied) {
|
||
img = img.convertToFormat(QImage::Format_ARGB32_Premultiplied);
|
||
}
|
||
v.image = img;
|
||
}
|
||
}
|
||
m_entities.push_back(v);
|
||
}
|
||
|
||
// 绘制/命中顺序：深度小（远）先画，大（近）后画，近处盖住远处
|
||
std::stable_sort(m_entities.begin(), m_entities.end(),
|
||
[](const Entity& a, const Entity& b) {
|
||
if (a.depth != b.depth) {
|
||
return a.depth < b.depth;
|
||
}
|
||
return a.id < b.id;
|
||
});
|
||
|
||
m_selectedEntity = -1;
|
||
if (!prevSelectedId.isEmpty()) {
|
||
for (int i = 0; i < m_entities.size(); ++i) {
|
||
if (m_entities[i].id == prevSelectedId) {
|
||
m_selectedEntity = i;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (m_selectedEntity >= 0) {
|
||
const auto& ent = m_entities[m_selectedEntity];
|
||
const QPointF origin =
|
||
ent.polygonWorld.isEmpty() ? ent.rect.center() : entity_cutout::polygonCentroid(ent.polygonWorld);
|
||
emit selectedEntityChanged(true, ent.id, ent.depth, origin);
|
||
} else if (!prevSelectedId.isEmpty()) {
|
||
emit selectedEntityChanged(false, QString(), 0, QPointF());
|
||
}
|
||
|
||
m_bgCutoutDirty = true;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setCurrentFrame(int frame) {
|
||
if (m_currentFrame == frame) {
|
||
return;
|
||
}
|
||
m_currentFrame = std::max(0, frame);
|
||
// 仅切帧时，实体由 MainWindow 刷新时回灌；这里也触发重绘用于坐标轴/叠加
|
||
update();
|
||
}
|
||
|
||
QPointF EditorCanvas::selectedAnimatedOriginWorld() const {
|
||
if (m_selectedEntity < 0 || m_selectedEntity >= m_entities.size()) {
|
||
return {};
|
||
}
|
||
return m_entities[m_selectedEntity].animatedOriginWorld;
|
||
}
|
||
|
||
double EditorCanvas::selectedDepthScale01() const {
|
||
if (m_selectedEntity < 0 || m_selectedEntity >= m_entities.size()) {
|
||
return 0.5;
|
||
}
|
||
return m_entities[m_selectedEntity].animatedDepthScale01;
|
||
}
|
||
|
||
QPointF EditorCanvas::selectedEntityCentroidWorld() const {
|
||
if (m_selectedEntity < 0 || m_selectedEntity >= m_entities.size()) {
|
||
return {};
|
||
}
|
||
// 拖动预览：polygonWorld 不再逐点更新，质心应使用预览值，否则属性面板看起来“不跟随”
|
||
if (!m_presentationPreviewMode && m_draggingEntity && m_dragPreviewActive && m_selectedEntity >= 0) {
|
||
return m_dragCentroidBase + m_dragDelta;
|
||
}
|
||
const auto& ent = m_entities[m_selectedEntity];
|
||
if (!ent.polygonWorld.isEmpty()) {
|
||
return entity_cutout::polygonCentroid(ent.polygonWorld);
|
||
}
|
||
return ent.rect.center();
|
||
}
|
||
|
||
double EditorCanvas::selectedDistanceScaleMultiplier() const {
|
||
if (m_selectedEntity < 0 || m_selectedEntity >= m_entities.size()) {
|
||
return 1.0;
|
||
}
|
||
const auto& ent = m_entities[m_selectedEntity];
|
||
return distanceScaleFromDepth01(ent.animatedDepthScale01, ent.distanceScaleCalibMult);
|
||
}
|
||
|
||
double EditorCanvas::selectedUserScale() const {
|
||
if (m_selectedEntity < 0 || m_selectedEntity >= m_entities.size()) {
|
||
return 1.0;
|
||
}
|
||
return m_entities[m_selectedEntity].userScale;
|
||
}
|
||
|
||
double EditorCanvas::selectedCombinedScale() const {
|
||
return selectedDistanceScaleMultiplier() * selectedUserScale();
|
||
}
|
||
|
||
void EditorCanvas::tickPresentationHoverAnimation() {
|
||
if (!m_presentationPreviewMode) {
|
||
return;
|
||
}
|
||
m_presHoverPhase += 0.35;
|
||
if (m_presHoverPhase > 6.28318530718) {
|
||
m_presHoverPhase -= 6.28318530718;
|
||
}
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::tickPresentationZoomAnimation() {
|
||
m_presZoomAnimT += 0.16;
|
||
qreal u = std::min(1.0, static_cast<qreal>(m_presZoomAnimT));
|
||
u = 1.0 - std::pow(1.0 - u, 3.0);
|
||
m_pan = m_presZoomFromPan + (m_presZoomToPan - m_presZoomFromPan) * u;
|
||
m_scale = m_presZoomFromScale + (m_presZoomToScale - m_presZoomFromScale) * u;
|
||
if (m_presZoomAnimT >= 1.0) {
|
||
m_presZoomTimer->stop();
|
||
m_pan = m_presZoomToPan;
|
||
m_scale = m_presZoomToScale;
|
||
if (m_presZoomFinishingRestore) {
|
||
m_presFocusedEntityIndex = -1;
|
||
m_presZoomFinishingRestore = false;
|
||
}
|
||
}
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::presentationComputeZoomTarget(int entityIndex, QPointF* outPan, qreal* outScale) const {
|
||
if (!outPan || !outScale || entityIndex < 0 || entityIndex >= m_entities.size()) {
|
||
return;
|
||
}
|
||
const Entity& ent = m_entities[entityIndex];
|
||
QRectF bb;
|
||
if (!ent.image.isNull()) {
|
||
const QSizeF sz(ent.image.width() * ent.visualScale, ent.image.height() * ent.visualScale);
|
||
bb = QRectF(ent.imageTopLeft, sz);
|
||
} else if (!ent.polygonWorld.isEmpty()) {
|
||
bb = entity_cutout::pathFromWorldPolygon(ent.polygonWorld).boundingRect();
|
||
} else {
|
||
bb = ent.rect;
|
||
}
|
||
const QPointF c = bb.center();
|
||
const qreal rw = std::max(1.0, bb.width());
|
||
const qreal rh = std::max(1.0, bb.height());
|
||
qreal s = std::min(static_cast<qreal>(width()) / (rw * 1.28), static_cast<qreal>(height()) / (rh * 1.28));
|
||
s = std::clamp(s, 0.12, 14.0);
|
||
*outScale = s;
|
||
*outPan = QPointF(width() / 2.0, height() / 2.0) - c * s;
|
||
}
|
||
|
||
void EditorCanvas::beginPresentationZoomTowardEntity(int entityIndex) {
|
||
if (entityIndex < 0 || entityIndex >= m_entities.size()) {
|
||
return;
|
||
}
|
||
if (m_presFocusedEntityIndex < 0) {
|
||
m_presRestorePan = m_pan;
|
||
m_presRestoreScale = m_scale;
|
||
}
|
||
m_presFocusedEntityIndex = entityIndex;
|
||
m_presZoomFromPan = m_pan;
|
||
m_presZoomFromScale = m_scale;
|
||
presentationComputeZoomTarget(entityIndex, &m_presZoomToPan, &m_presZoomToScale);
|
||
m_presZoomAnimT = 0.0;
|
||
m_presZoomFinishingRestore = false;
|
||
m_presZoomTimer->start();
|
||
}
|
||
|
||
void EditorCanvas::beginPresentationZoomRestore() {
|
||
m_presZoomFromPan = m_pan;
|
||
m_presZoomFromScale = m_scale;
|
||
m_presZoomToPan = m_presRestorePan;
|
||
m_presZoomToScale = m_presRestoreScale;
|
||
m_presZoomAnimT = 0.0;
|
||
m_presZoomFinishingRestore = true;
|
||
m_presZoomTimer->start();
|
||
}
|
||
|
||
void EditorCanvas::clearPresentationEntityFocus() {
|
||
emit presentationInteractionDismissed();
|
||
if (m_presZoomFinishingRestore) {
|
||
return;
|
||
}
|
||
if (m_presFocusedEntityIndex >= 0) {
|
||
beginPresentationZoomRestore();
|
||
}
|
||
}
|
||
|
||
void EditorCanvas::clearEntitySelection() {
|
||
if (m_selectedEntity < 0) {
|
||
return;
|
||
}
|
||
m_selectedEntity = -1;
|
||
emit selectedEntityChanged(false, QString(), 0, QPointF());
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::selectEntityById(const QString& id) {
|
||
if (id.isEmpty()) {
|
||
clearEntitySelection();
|
||
return;
|
||
}
|
||
for (int i = 0; i < m_entities.size(); ++i) {
|
||
if (m_entities[i].id != id) {
|
||
continue;
|
||
}
|
||
if (m_selectedEntity == i) {
|
||
update();
|
||
return;
|
||
}
|
||
m_selectedEntity = i;
|
||
const auto& ent = m_entities[i];
|
||
const QPointF origin =
|
||
ent.polygonWorld.isEmpty() ? ent.rect.center() : entity_cutout::polygonCentroid(ent.polygonWorld);
|
||
emit selectedEntityChanged(true, ent.id, ent.depth, origin);
|
||
update();
|
||
return;
|
||
}
|
||
clearEntitySelection();
|
||
}
|
||
|
||
void EditorCanvas::setBackgroundImagePath(const QString& absolutePath) {
|
||
if (m_bgAbsPath == absolutePath) {
|
||
return;
|
||
}
|
||
m_bgAbsPath = absolutePath;
|
||
invalidatePixmap();
|
||
m_bgImageDirty = true;
|
||
m_bgCutoutDirty = true;
|
||
m_bgImage = QImage();
|
||
m_bgImageCutout = QImage();
|
||
zoomToFit();
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setBackgroundVisible(bool on) {
|
||
if (m_backgroundVisible == on) {
|
||
return;
|
||
}
|
||
m_backgroundVisible = on;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setDepthMapPath(const QString& absolutePath) {
|
||
if (m_depthAbsPath == absolutePath) {
|
||
return;
|
||
}
|
||
m_depthAbsPath = absolutePath;
|
||
m_depthDirty = true;
|
||
m_depthImage8 = QImage();
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setDepthOverlayEnabled(bool on) {
|
||
if (m_depthOverlayEnabled == on) {
|
||
return;
|
||
}
|
||
m_depthOverlayEnabled = on;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setTool(Tool tool) {
|
||
if (m_tool == tool) {
|
||
return;
|
||
}
|
||
m_tool = tool;
|
||
m_draggingEntity = false;
|
||
m_drawingEntity = false;
|
||
m_strokeWorld.clear();
|
||
updateCursor();
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setEntityCreateSegmentMode(EntityCreateSegmentMode m) {
|
||
if (m_entityCreateSegmentMode == m) {
|
||
return;
|
||
}
|
||
m_entityCreateSegmentMode = m;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setPendingEntityPolygonWorld(const QVector<QPointF>& polyWorld) {
|
||
m_pendingPolyWorld = polyWorld;
|
||
m_pendingDragging = false;
|
||
m_pendingDragWhole = false;
|
||
m_pendingDragVertex = -1;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::clearPendingEntityPolygon() {
|
||
m_pendingPolyWorld.clear();
|
||
m_pendingDragging = false;
|
||
m_pendingDragWhole = false;
|
||
m_pendingDragVertex = -1;
|
||
update();
|
||
}
|
||
|
||
bool EditorCanvas::isPointNearPendingVertex(const QPointF& worldPos, int* outIndex) const {
|
||
if (outIndex) *outIndex = -1;
|
||
if (m_pendingPolyWorld.size() < 3) return false;
|
||
const qreal rView = 10.0;
|
||
const qreal rWorld = rView / std::max<qreal>(m_scale, 0.001);
|
||
const qreal r2 = rWorld * rWorld;
|
||
int best = -1;
|
||
qreal bestD2 = r2;
|
||
for (int i = 0; i < m_pendingPolyWorld.size(); ++i) {
|
||
const QPointF d = m_pendingPolyWorld[i] - worldPos;
|
||
const qreal d2 = d.x() * d.x() + d.y() * d.y();
|
||
if (d2 <= bestD2) {
|
||
bestD2 = d2;
|
||
best = i;
|
||
}
|
||
}
|
||
if (best >= 0) {
|
||
if (outIndex) *outIndex = best;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool EditorCanvas::pendingPolygonContains(const QPointF& worldPos) const {
|
||
if (m_pendingPolyWorld.size() < 3) return false;
|
||
return entity_cutout::pathFromWorldPolygon(m_pendingPolyWorld).contains(worldPos);
|
||
}
|
||
|
||
void EditorCanvas::resetView() {
|
||
m_scale = 1.0;
|
||
m_pan = QPointF(0, 0);
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::zoomToFit() {
|
||
ensurePixmapLoaded();
|
||
if (m_bgPixmap.isNull() || width() <= 1 || height() <= 1) {
|
||
resetView();
|
||
return;
|
||
}
|
||
|
||
const QSizeF viewSize = size();
|
||
const QSizeF imgSize = m_bgPixmap.size();
|
||
const qreal sx = (viewSize.width() - 24.0) / imgSize.width();
|
||
const qreal sy = (viewSize.height() - 24.0) / imgSize.height();
|
||
const qreal s = std::max<qreal>(0.05, std::min(sx, sy));
|
||
|
||
m_scale = s;
|
||
// 让 world(0,0) 的图像左上角居中显示
|
||
const QSizeF draw(imgSize.width() * s, imgSize.height() * s);
|
||
m_pan = QPointF((viewSize.width() - draw.width()) / 2.0, (viewSize.height() - draw.height()) / 2.0);
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setWorldAxesVisible(bool on) {
|
||
if (m_worldAxesVisible == on) {
|
||
return;
|
||
}
|
||
m_worldAxesVisible = on;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setAxisLabelsVisible(bool on) {
|
||
if (m_axisLabelsVisible == on) {
|
||
return;
|
||
}
|
||
m_axisLabelsVisible = on;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setGizmoLabelsVisible(bool on) {
|
||
if (m_gizmoLabelsVisible == on) {
|
||
return;
|
||
}
|
||
m_gizmoLabelsVisible = on;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setGridVisible(bool on) {
|
||
if (m_gridVisible == on) {
|
||
return;
|
||
}
|
||
m_gridVisible = on;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::setCheckerboardVisible(bool on) {
|
||
if (m_checkerboardVisible == on) {
|
||
return;
|
||
}
|
||
m_checkerboardVisible = on;
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::invalidatePixmap() {
|
||
m_pixmapDirty = true;
|
||
m_bgPixmap = QPixmap();
|
||
}
|
||
|
||
void EditorCanvas::ensurePixmapLoaded() const {
|
||
if (!m_pixmapDirty) {
|
||
return;
|
||
}
|
||
m_pixmapDirty = false;
|
||
m_bgPixmap = QPixmap();
|
||
if (!m_bgAbsPath.isEmpty()) {
|
||
m_bgPixmap = QPixmap(m_bgAbsPath);
|
||
}
|
||
m_bgImageDirty = true;
|
||
m_bgCutoutDirty = true;
|
||
}
|
||
|
||
void EditorCanvas::updateCursor() {
|
||
if (m_presentationPreviewMode) {
|
||
if (m_presHoverEntityIndex >= 0) {
|
||
setCursor(Qt::PointingHandCursor);
|
||
} else {
|
||
setCursor(Qt::OpenHandCursor);
|
||
}
|
||
return;
|
||
}
|
||
switch (m_tool) {
|
||
case Tool::Move:
|
||
setCursor(Qt::OpenHandCursor);
|
||
break;
|
||
case Tool::Zoom:
|
||
setCursor(Qt::CrossCursor);
|
||
break;
|
||
case Tool::CreateEntity:
|
||
setCursor(Qt::CrossCursor);
|
||
break;
|
||
}
|
||
}
|
||
|
||
QPointF EditorCanvas::viewToWorld(const QPointF& v) const {
|
||
if (m_scale <= 0.0) {
|
||
return {};
|
||
}
|
||
return (v - m_pan) / m_scale;
|
||
}
|
||
|
||
QPointF EditorCanvas::worldToView(const QPointF& w) const {
|
||
return w * m_scale + m_pan;
|
||
}
|
||
|
||
QRectF EditorCanvas::worldRectOfBackground() const {
|
||
ensurePixmapLoaded();
|
||
if (m_bgPixmap.isNull()) {
|
||
return {};
|
||
}
|
||
return QRectF(0, 0, m_bgPixmap.width(), m_bgPixmap.height());
|
||
}
|
||
|
||
int EditorCanvas::hitTestEntity(const QPointF& worldPos) const {
|
||
for (qsizetype i = m_entities.size(); i > 0; --i) {
|
||
const qsizetype idx = i - 1;
|
||
const auto& ent = m_entities[idx];
|
||
if (ent.hiddenInEditMode) {
|
||
continue;
|
||
}
|
||
if (!ent.polygonWorld.isEmpty()) {
|
||
const QPainterPath path = entity_cutout::pathFromWorldPolygon(ent.polygonWorld);
|
||
if (path.contains(worldPos)) {
|
||
return static_cast<int>(idx);
|
||
}
|
||
continue;
|
||
}
|
||
if (ent.rect.contains(worldPos)) {
|
||
return static_cast<int>(idx);
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
void EditorCanvas::paintEvent(QPaintEvent* e) {
|
||
Q_UNUSED(e);
|
||
|
||
QPainter p(this);
|
||
p.setRenderHint(QPainter::Antialiasing, false);
|
||
// 拖动时优先保证交互帧率：缩放贴图使用 nearest 以减少开销
|
||
p.setRenderHint(QPainter::SmoothPixmapTransform, !m_draggingEntity);
|
||
|
||
const QRect r = rect();
|
||
if (!m_presentationPreviewMode) {
|
||
if (m_checkerboardVisible) {
|
||
drawCheckerboard(p, r);
|
||
}
|
||
if (m_gridVisible) {
|
||
drawGrid(p, r);
|
||
}
|
||
}
|
||
|
||
ensurePixmapLoaded();
|
||
if (m_bgAbsPath.isEmpty()) {
|
||
p.setPen(palette().text().color());
|
||
p.drawText(r.adjusted(12, 12, -12, -12), Qt::AlignCenter,
|
||
QStringLiteral("（暂无背景）\n右键项目树中的“背景”可更换/裁剪"));
|
||
return;
|
||
}
|
||
if (m_bgPixmap.isNull()) {
|
||
p.setPen(palette().text().color());
|
||
p.drawText(r.adjusted(12, 12, -12, -12), Qt::AlignCenter,
|
||
QStringLiteral("（背景加载失败）\n%1").arg(m_bgAbsPath));
|
||
return;
|
||
}
|
||
|
||
// 预览：始终加载完整背景图，不做抠洞
|
||
const bool showBg = m_presentationPreviewMode || m_backgroundVisible;
|
||
if (showBg) {
|
||
if (m_bgImageDirty) {
|
||
m_bgImageDirty = false;
|
||
m_bgImage = QImage(m_bgAbsPath);
|
||
if (m_bgImage.format() != QImage::Format_ARGB32_Premultiplied && !m_bgImage.isNull()) {
|
||
m_bgImage = m_bgImage.convertToFormat(QImage::Format_ARGB32_Premultiplied);
|
||
}
|
||
m_bgCutoutDirty = true;
|
||
}
|
||
if (!m_presentationPreviewMode && m_bgCutoutDirty) {
|
||
m_bgCutoutDirty = false;
|
||
m_bgImageCutout = m_bgImage;
|
||
for (const auto& ent : m_entities) {
|
||
if (!ent.cutoutPolygonWorld.isEmpty() && !m_bgImageCutout.isNull()) {
|
||
entity_cutout::applyBlackFillToBackground(m_bgImageCutout, ent.cutoutPolygonWorld);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 以“世界坐标”绘制：支持缩放/平移
|
||
p.save();
|
||
QTransform t;
|
||
t.translate(m_pan.x(), m_pan.y());
|
||
t.scale(m_scale, m_scale);
|
||
p.setTransform(t, true);
|
||
|
||
// 背景（预览：完整图；编辑：可抠洞 / 可隐藏看深度）
|
||
if (showBg) {
|
||
if (m_presentationPreviewMode) {
|
||
if (!m_bgImage.isNull()) {
|
||
p.drawImage(QPointF(0, 0), m_bgImage);
|
||
} else {
|
||
p.drawPixmap(QPointF(0, 0), m_bgPixmap);
|
||
}
|
||
} else if (m_backgroundVisible) {
|
||
if (!m_bgImageCutout.isNull()) {
|
||
p.drawImage(QPointF(0, 0), m_bgImageCutout);
|
||
} else {
|
||
p.drawPixmap(QPointF(0, 0), m_bgPixmap);
|
||
}
|
||
}
|
||
if (!m_presentationPreviewMode && m_backgroundVisible) {
|
||
p.setPen(QPen(QColor(0, 0, 0, 80), 1.0 / std::max<qreal>(m_scale, 0.001)));
|
||
p.drawRect(QRectF(0, 0, m_bgPixmap.width(), m_bgPixmap.height()).adjusted(0, 0, -1, -1));
|
||
}
|
||
}
|
||
|
||
// 深度叠加（伪彩色）：仅由「叠加深度」开关控制，与是否显示背景无关
|
||
const bool wantDepth =
|
||
!m_presentationPreviewMode && (!m_depthAbsPath.isEmpty()) && m_depthOverlayEnabled;
|
||
if (wantDepth) {
|
||
if (m_depthDirty) {
|
||
m_depthDirty = false;
|
||
QImage img(m_depthAbsPath);
|
||
m_depthImage8 = img.isNull() ? QImage() : img.convertToFormat(QImage::Format_Grayscale8);
|
||
}
|
||
if (!m_depthImage8.isNull()) {
|
||
const int overlayAlpha = m_backgroundVisible ? m_depthOverlayAlpha : 255;
|
||
const QImage overlay =
|
||
core::DepthService::depthToColormapOverlay(m_depthImage8, overlayAlpha);
|
||
if (!overlay.isNull()) {
|
||
p.drawImage(QPointF(0, 0), overlay);
|
||
} else {
|
||
p.drawImage(QPointF(0, 0), m_depthImage8);
|
||
}
|
||
p.setPen(QPen(QColor(0, 0, 0, 80), 1.0 / std::max<qreal>(m_scale, 0.001)));
|
||
p.drawRect(QRectF(0, 0, m_depthImage8.width(), m_depthImage8.height()).adjusted(0, 0, -1, -1));
|
||
}
|
||
}
|
||
|
||
// 实体元素（占位）：后续可替换为真实数据
|
||
for (int i = 0; i < m_entities.size(); ++i) {
|
||
const auto& ent = m_entities[i];
|
||
if (ent.hiddenInEditMode && i != m_selectedEntity) {
|
||
continue;
|
||
}
|
||
const bool isDragPreview = (!m_presentationPreviewMode && m_draggingEntity && m_dragPreviewActive && i == m_selectedEntity);
|
||
if (!ent.polygonWorld.isEmpty()) {
|
||
// 优先绘制抠出来的实体图像（独立存在）
|
||
if (!ent.image.isNull()) {
|
||
if (isDragPreview) {
|
||
// 预览：先平移，再围绕“基准质心”缩放（避免把 delta 叠加两次导致错位）
|
||
const QPointF cBase = m_dragCentroidBase;
|
||
p.save();
|
||
QTransform tr;
|
||
tr.translate(m_dragDelta.x(), m_dragDelta.y());
|
||
tr.translate(cBase.x(), cBase.y());
|
||
tr.scale(m_dragScaleRatio, m_dragScaleRatio);
|
||
tr.translate(-cBase.x(), -cBase.y());
|
||
p.setTransform(tr, true);
|
||
const QSizeF sz(ent.image.width() * m_dragScaleBase, ent.image.height() * m_dragScaleBase);
|
||
const QRectF target(m_dragImageTopLeftBase, sz);
|
||
p.drawImage(target, ent.image);
|
||
p.restore();
|
||
} else {
|
||
const qreal pop =
|
||
(m_presentationPreviewMode && i == m_presFocusedEntityIndex) ? 1.1 : 1.0;
|
||
const QSizeF sz0(ent.image.width() * ent.visualScale, ent.image.height() * ent.visualScale);
|
||
QRectF target;
|
||
if (pop > 1.001) {
|
||
const QRectF orig(ent.imageTopLeft, sz0);
|
||
const QPointF cen = orig.center();
|
||
const QSizeF sz = orig.size() * pop;
|
||
target = QRectF(QPointF(cen.x() - sz.width() * 0.5, cen.y() - sz.height() * 0.5), sz);
|
||
} else {
|
||
target = QRectF(ent.imageTopLeft, sz0);
|
||
}
|
||
p.drawImage(target, ent.image);
|
||
}
|
||
} else {
|
||
const QPolygonF poly(isDragPreview ? QPolygonF(m_dragPolyBase) : QPolygonF(ent.polygonWorld));
|
||
p.setPen(Qt::NoPen);
|
||
p.setBrush(ent.color);
|
||
if (isDragPreview) {
|
||
const QPointF cBase = m_dragCentroidBase;
|
||
QTransform tr;
|
||
tr.translate(m_dragDelta.x(), m_dragDelta.y());
|
||
tr.translate(cBase.x(), cBase.y());
|
||
tr.scale(m_dragScaleRatio, m_dragScaleRatio);
|
||
tr.translate(-cBase.x(), -cBase.y());
|
||
p.save();
|
||
p.setTransform(tr, true);
|
||
p.drawPolygon(poly);
|
||
p.restore();
|
||
} else {
|
||
p.drawPolygon(poly);
|
||
}
|
||
}
|
||
if (!m_presentationPreviewMode) {
|
||
p.setBrush(Qt::NoBrush);
|
||
p.setPen(QPen(QColor(0, 0, 0, 160), 1.0 / std::max<qreal>(m_scale, 0.001)));
|
||
if (isDragPreview) {
|
||
const QPointF cBase = m_dragCentroidBase;
|
||
QTransform tr;
|
||
tr.translate(m_dragDelta.x(), m_dragDelta.y());
|
||
tr.translate(cBase.x(), cBase.y());
|
||
tr.scale(m_dragScaleRatio, m_dragScaleRatio);
|
||
tr.translate(-cBase.x(), -cBase.y());
|
||
p.save();
|
||
p.setTransform(tr, true);
|
||
p.drawPath(m_dragPathBase);
|
||
p.restore();
|
||
} else {
|
||
p.drawPath(ent.pathWorld);
|
||
}
|
||
}
|
||
} else {
|
||
p.fillRect(ent.rect, ent.color);
|
||
if (!m_presentationPreviewMode) {
|
||
p.setPen(QPen(QColor(0, 0, 0, 120), 1.0 / std::max<qreal>(m_scale, 0.001)));
|
||
p.drawRect(ent.rect);
|
||
}
|
||
}
|
||
if (!m_presentationPreviewMode && i == m_selectedEntity) {
|
||
p.setPen(QPen(QColor(255, 120, 0, 220), 2.0 / std::max<qreal>(m_scale, 0.001)));
|
||
if (!ent.polygonWorld.isEmpty()) {
|
||
if (isDragPreview) {
|
||
const QPointF cBase = m_dragCentroidBase;
|
||
QTransform tr;
|
||
tr.translate(m_dragDelta.x(), m_dragDelta.y());
|
||
tr.translate(cBase.x(), cBase.y());
|
||
tr.scale(m_dragScaleRatio, m_dragScaleRatio);
|
||
tr.translate(-cBase.x(), -cBase.y());
|
||
p.save();
|
||
p.setTransform(tr, true);
|
||
p.drawPath(m_dragPathBase);
|
||
p.restore();
|
||
} else {
|
||
p.drawPath(ent.pathWorld);
|
||
}
|
||
} else {
|
||
p.drawRect(ent.rect.adjusted(-2, -2, 2, 2));
|
||
}
|
||
}
|
||
if (m_presentationPreviewMode && !ent.hiddenInEditMode) {
|
||
const bool showHover = (i == m_presHoverEntityIndex);
|
||
const bool showFocus = (i == m_presFocusedEntityIndex);
|
||
if (showHover || showFocus) {
|
||
p.setBrush(Qt::NoBrush);
|
||
if (showHover) {
|
||
const qreal pulse = 0.45 + 0.55 * std::sin(static_cast<double>(m_presHoverPhase));
|
||
const qreal lw =
|
||
(2.0 + 2.8 * pulse) / std::max(static_cast<qreal>(m_scale), static_cast<qreal>(0.001));
|
||
p.setPen(QPen(QColor(255, 210, 80, static_cast<int>(65 + 110 * pulse)), lw));
|
||
if (!ent.pathWorld.isEmpty()) {
|
||
p.drawPath(ent.pathWorld);
|
||
} else {
|
||
p.drawRect(ent.rect);
|
||
}
|
||
}
|
||
if (showFocus) {
|
||
const qreal lw = 2.8 / std::max(static_cast<qreal>(m_scale), static_cast<qreal>(0.001));
|
||
p.setPen(QPen(QColor(255, 120, 40, 230), lw));
|
||
if (!ent.pathWorld.isEmpty()) {
|
||
p.drawPath(ent.pathWorld);
|
||
} else {
|
||
p.drawRect(ent.rect);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 创建实体：手绘轨迹预览（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));
|
||
p.setPen(pen);
|
||
p.setBrush(Qt::NoBrush);
|
||
p.drawPolyline(QPolygonF(m_strokeWorld));
|
||
// 提示闭合
|
||
p.setPen(QPen(QColor(255, 120, 0, 140), 1.0 / std::max<qreal>(m_scale, 0.001), Qt::DashLine));
|
||
p.drawLine(m_strokeWorld.first(), m_strokeWorld.last());
|
||
}
|
||
|
||
// 待确认实体：多边形预览 + 顶点
|
||
if (!m_presentationPreviewMode && m_pendingPolyWorld.size() >= 3) {
|
||
const qreal lw = 2.5 / std::max<qreal>(m_scale, 0.001);
|
||
p.setPen(QPen(QColor(60, 180, 255, 230), lw));
|
||
p.setBrush(QColor(60, 180, 255, 45));
|
||
const QPainterPath path = entity_cutout::pathFromWorldPolygon(m_pendingPolyWorld);
|
||
p.drawPath(path);
|
||
const qreal vr = 5.0 / std::max<qreal>(m_scale, 0.001);
|
||
p.setPen(QPen(QColor(0, 0, 0, 120), lw));
|
||
p.setBrush(QColor(255, 255, 255, 220));
|
||
for (const QPointF& v : m_pendingPolyWorld) {
|
||
p.drawEllipse(v, vr, vr);
|
||
}
|
||
}
|
||
|
||
p.restore();
|
||
|
||
// 坐标轴/刻度：绘制在画布最外层，背景越界时贴边显示
|
||
ensurePixmapLoaded();
|
||
if (!m_presentationPreviewMode && m_worldAxesVisible && !m_bgPixmap.isNull()) {
|
||
const QPointF originView = worldToView(QPointF(0, 0));
|
||
const qreal axisX = std::clamp(originView.x(), 0.0, static_cast<qreal>(width()));
|
||
const qreal axisY = std::clamp(originView.y(), 0.0, static_cast<qreal>(height()));
|
||
|
||
QPen axisPen(QColor(20, 20, 20, 180));
|
||
axisPen.setWidth(2);
|
||
p.setPen(axisPen);
|
||
p.drawLine(QPointF(0, axisY), QPointF(width(), axisY)); // X 轴（水平）
|
||
p.drawLine(QPointF(axisX, 0), QPointF(axisX, height())); // Y 轴（垂直）
|
||
|
||
const int step = 100;
|
||
QPen tickPen(QColor(20, 20, 20, 140));
|
||
tickPen.setWidth(1);
|
||
p.setPen(tickPen);
|
||
if (m_axisLabelsVisible) {
|
||
QFont f = p.font();
|
||
f.setPointSize(std::max(7, f.pointSize() - 1));
|
||
p.setFont(f);
|
||
}
|
||
|
||
// X 轴：用 y=0 的世界线映射到 view-x，并把刻度画在 axisY 上
|
||
for (int x = 0; x <= m_bgPixmap.width(); x += step) {
|
||
const QPointF vx = worldToView(QPointF(x, 0));
|
||
if (vx.x() < -50 || vx.x() > width() + 50) {
|
||
continue;
|
||
}
|
||
const qreal tx = std::clamp(vx.x(), 0.0, static_cast<qreal>(width()));
|
||
p.drawLine(QPointF(tx, axisY), QPointF(tx, axisY + 6));
|
||
if (m_axisLabelsVisible) {
|
||
p.drawText(QPointF(tx + 2, axisY + 18), QString::number(x));
|
||
}
|
||
}
|
||
|
||
// Y 轴：用 x=0 的世界线映射到 view-y，并把刻度画在 axisX 上
|
||
for (int y = 0; y <= m_bgPixmap.height(); y += step) {
|
||
const QPointF vy = worldToView(QPointF(0, y));
|
||
if (vy.y() < -50 || vy.y() > height() + 50) {
|
||
continue;
|
||
}
|
||
const qreal ty = std::clamp(vy.y(), 0.0, static_cast<qreal>(height()));
|
||
p.drawLine(QPointF(axisX, ty), QPointF(axisX + 6, ty));
|
||
if (m_axisLabelsVisible) {
|
||
p.drawText(QPointF(axisX + 10, ty - 2), QString::number(y));
|
||
}
|
||
}
|
||
}
|
||
|
||
// Gizmo：选中实体时显示（仿 Blender：约束 X/Y 轴移动）
|
||
if (!m_presentationPreviewMode && m_selectedEntity >= 0 && m_selectedEntity < m_entities.size()) {
|
||
const auto& ent = m_entities[m_selectedEntity];
|
||
const bool isDragPreview = (m_draggingEntity && m_dragPreviewActive);
|
||
QPointF originWorld = ent.rect.center();
|
||
if (isDragPreview) {
|
||
originWorld = m_dragCentroidBase + m_dragDelta;
|
||
} else if (!ent.polygonWorld.isEmpty()) {
|
||
originWorld = entity_cutout::polygonCentroid(ent.polygonWorld);
|
||
}
|
||
const QPointF originView = worldToView(originWorld);
|
||
|
||
const qreal len = 56.0;
|
||
QPen xPen(QColor(220, 60, 60, 220));
|
||
xPen.setWidth(2);
|
||
QPen yPen(QColor(60, 180, 90, 220));
|
||
yPen.setWidth(2);
|
||
|
||
// X 轴
|
||
p.setPen(xPen);
|
||
p.drawLine(originView, QPointF(originView.x() + len, originView.y()));
|
||
p.drawRect(QRectF(QPointF(originView.x() + len - 4, originView.y() - 4), QSizeF(8, 8)));
|
||
if (m_gizmoLabelsVisible) {
|
||
p.drawText(QPointF(originView.x() + len + 6, originView.y() + 4), QStringLiteral("X"));
|
||
}
|
||
|
||
// Y 轴
|
||
p.setPen(yPen);
|
||
p.drawLine(originView, QPointF(originView.x(), originView.y() + len));
|
||
p.drawRect(QRectF(QPointF(originView.x() - 4, originView.y() + len - 4), QSizeF(8, 8)));
|
||
if (m_gizmoLabelsVisible) {
|
||
p.drawText(QPointF(originView.x() + 6, originView.y() + len + 14), QStringLiteral("Y"));
|
||
}
|
||
}
|
||
}
|
||
|
||
void EditorCanvas::resizeEvent(QResizeEvent* e) {
|
||
QWidget::resizeEvent(e);
|
||
// 仅触发重绘；pixmap 只缓存原图
|
||
update();
|
||
}
|
||
|
||
void EditorCanvas::mousePressEvent(QMouseEvent* e) {
|
||
if (e->button() != Qt::LeftButton && e->button() != Qt::MiddleButton) {
|
||
QWidget::mousePressEvent(e);
|
||
return;
|
||
}
|
||
|
||
const QPointF wp0 = viewToWorld(e->position());
|
||
emit hoveredWorldPosChanged(wp0);
|
||
int z0 = -1;
|
||
if (!m_depthAbsPath.isEmpty()) {
|
||
if (m_depthDirty) {
|
||
m_depthDirty = false;
|
||
QImage img(m_depthAbsPath);
|
||
m_depthImage8 = img.isNull() ? QImage() : img.convertToFormat(QImage::Format_Grayscale8);
|
||
}
|
||
if (!m_depthImage8.isNull()) {
|
||
const int xi = static_cast<int>(std::floor(wp0.x()));
|
||
const int yi = static_cast<int>(std::floor(wp0.y()));
|
||
if (xi >= 0 && yi >= 0 && xi < m_depthImage8.width() && yi < m_depthImage8.height()) {
|
||
z0 = static_cast<int>(m_depthImage8.constScanLine(yi)[xi]);
|
||
}
|
||
}
|
||
}
|
||
emit hoveredWorldPosDepthChanged(wp0, z0);
|
||
|
||
if (m_presentationPreviewMode) {
|
||
if (e->button() == Qt::LeftButton) {
|
||
const int hit = hitTestEntity(wp0);
|
||
if (hit >= 0) {
|
||
const auto& ent = m_entities[hit];
|
||
const QPointF cWorld =
|
||
ent.polygonWorld.isEmpty() ? ent.rect.center() : entity_cutout::polygonCentroid(ent.polygonWorld);
|
||
const QPointF anchorView = worldToView(cWorld);
|
||
beginPresentationZoomTowardEntity(hit);
|
||
emit presentationEntityIntroRequested(ent.id, anchorView);
|
||
return;
|
||
}
|
||
m_dragging = true;
|
||
m_presBgPanSession = true;
|
||
m_presBgDragDist = 0.0;
|
||
m_lastMouseView = e->position();
|
||
setCursor(Qt::ClosedHandCursor);
|
||
return;
|
||
}
|
||
if (e->button() == Qt::MiddleButton) {
|
||
m_dragging = true;
|
||
m_presBgPanSession = false;
|
||
m_lastMouseView = e->position();
|
||
setCursor(Qt::ClosedHandCursor);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (m_tool == Tool::CreateEntity && e->button() == Qt::LeftButton) {
|
||
// 若已有待确认多边形：进入微调（顶点/整体拖拽），或点击空白直接确认
|
||
if (!m_presentationPreviewMode && m_pendingPolyWorld.size() >= 3) {
|
||
m_dragging = true;
|
||
m_lastMouseView = e->position();
|
||
const QPointF w = viewToWorld(e->position());
|
||
m_pendingLastMouseWorld = w;
|
||
int vi = -1;
|
||
if (isPointNearPendingVertex(w, &vi)) {
|
||
m_pendingDragging = true;
|
||
m_pendingDragVertex = vi;
|
||
m_pendingDragWhole = false;
|
||
e->accept();
|
||
return;
|
||
}
|
||
if (pendingPolygonContains(w)) {
|
||
m_pendingDragging = true;
|
||
m_pendingDragWhole = true;
|
||
m_pendingDragVertex = -1;
|
||
e->accept();
|
||
return;
|
||
}
|
||
// 点击空白：确认
|
||
emit requestFinalizePendingEntity(m_pendingPolyWorld);
|
||
e->accept();
|
||
return;
|
||
}
|
||
|
||
m_dragging = true;
|
||
m_drawingEntity = true;
|
||
m_draggingEntity = false;
|
||
m_selectedEntity = -1;
|
||
emit selectedEntityChanged(false, QString(), 0, QPointF());
|
||
m_lastMouseView = e->position();
|
||
m_strokeWorld.clear();
|
||
m_strokeWorld.push_back(viewToWorld(e->position()));
|
||
update();
|
||
return;
|
||
}
|
||
|
||
m_dragging = true;
|
||
m_lastMouseView = e->position();
|
||
const QPointF worldPos = viewToWorld(e->position());
|
||
|
||
if (e->button() == Qt::MiddleButton || m_tool == Tool::Move) {
|
||
setCursor(Qt::ClosedHandCursor);
|
||
}
|
||
|
||
if (m_tool == Tool::Move && e->button() == Qt::LeftButton) {
|
||
// 优先：若已选中实体，且点在 gizmo 手柄上，则开启轴约束拖动
|
||
if (m_selectedEntity >= 0 && m_selectedEntity < m_entities.size()) {
|
||
const auto& ent = m_entities[m_selectedEntity];
|
||
const bool isDragPreview = (m_draggingEntity && m_dragPreviewActive);
|
||
QPointF originWorld = ent.rect.center();
|
||
if (isDragPreview) {
|
||
originWorld = m_dragCentroidBase + m_dragDelta;
|
||
} else if (!ent.polygonWorld.isEmpty()) {
|
||
originWorld = entity_cutout::polygonCentroid(ent.polygonWorld);
|
||
}
|
||
const QPointF originView = worldToView(originWorld);
|
||
const GizmoHit gh = hitTestGizmo(e->position(), originView);
|
||
if (gh.mode == DragMode::AxisX || gh.mode == DragMode::AxisY) {
|
||
m_dragging = true;
|
||
m_draggingEntity = true;
|
||
m_dragMode = gh.mode;
|
||
m_lastMouseView = e->position();
|
||
m_dragStartMouseWorld = viewToWorld(e->position());
|
||
|
||
// 为了统一复用 move 逻辑：初始化 rect 与基准点
|
||
const QRectF r = m_entities[m_selectedEntity].rect.isNull() && !m_entities[m_selectedEntity].polygonWorld.isEmpty()
|
||
? entity_cutout::pathFromWorldPolygon(m_entities[m_selectedEntity].polygonWorld).boundingRect()
|
||
: m_entities[m_selectedEntity].rect;
|
||
m_entities[m_selectedEntity].rect = r;
|
||
m_entityDragOffsetOriginWorld = viewToWorld(e->position()) - m_entities[m_selectedEntity].animatedOriginWorld;
|
||
m_entityDragStartAnimatedOrigin = m_entities[m_selectedEntity].animatedOriginWorld;
|
||
// drag preview baseline
|
||
m_dragPreviewActive = true;
|
||
m_dragDelta = QPointF(0, 0);
|
||
m_dragOriginBase = m_entities[m_selectedEntity].animatedOriginWorld;
|
||
m_dragRectBase = m_entities[m_selectedEntity].rect;
|
||
m_dragImageTopLeftBase = m_entities[m_selectedEntity].imageTopLeft;
|
||
m_dragScaleBase = std::max(1e-6, m_entities[m_selectedEntity].visualScale);
|
||
m_dragScaleRatio = 1.0;
|
||
m_dragPolyBase = m_entities[m_selectedEntity].polygonWorld;
|
||
m_dragPathBase = m_entities[m_selectedEntity].pathWorld;
|
||
m_dragCentroidBase =
|
||
m_dragPolyBase.isEmpty() ? m_dragRectBase.center() : entity_cutout::polygonCentroid(m_dragPolyBase);
|
||
update();
|
||
return;
|
||
}
|
||
}
|
||
|
||
const int hit = hitTestEntity(worldPos);
|
||
if (hit >= 0) {
|
||
m_selectedEntity = hit;
|
||
m_draggingEntity = true;
|
||
m_dragMode = DragMode::Free;
|
||
emit entityDragActiveChanged(true);
|
||
const QRectF r = m_entities[hit].rect.isNull() && !m_entities[hit].polygonWorld.isEmpty()
|
||
? entity_cutout::pathFromWorldPolygon(m_entities[hit].polygonWorld).boundingRect()
|
||
: m_entities[hit].rect;
|
||
m_entities[hit].rect = r;
|
||
m_entityDragOffsetOriginWorld = worldPos - m_entities[hit].animatedOriginWorld;
|
||
m_entityDragStartAnimatedOrigin = m_entities[hit].animatedOriginWorld;
|
||
// drag preview baseline
|
||
m_dragPreviewActive = true;
|
||
m_dragDelta = QPointF(0, 0);
|
||
m_dragOriginBase = m_entities[hit].animatedOriginWorld;
|
||
m_dragRectBase = m_entities[hit].rect;
|
||
m_dragImageTopLeftBase = m_entities[hit].imageTopLeft;
|
||
m_dragScaleBase = std::max(1e-6, m_entities[hit].visualScale);
|
||
m_dragScaleRatio = 1.0;
|
||
m_dragPolyBase = m_entities[hit].polygonWorld;
|
||
m_dragPathBase = m_entities[hit].pathWorld;
|
||
m_dragCentroidBase =
|
||
m_dragPolyBase.isEmpty() ? m_dragRectBase.center() : entity_cutout::polygonCentroid(m_dragPolyBase);
|
||
const QPointF origin = !m_entities[hit].polygonWorld.isEmpty() ? entity_cutout::polygonCentroid(m_entities[hit].polygonWorld)
|
||
: m_entities[hit].rect.center();
|
||
emit selectedEntityChanged(true, m_entities[hit].id, m_entities[hit].depth, origin);
|
||
update();
|
||
return;
|
||
}
|
||
m_selectedEntity = -1;
|
||
m_draggingEntity = false;
|
||
m_dragMode = DragMode::None;
|
||
emit selectedEntityChanged(false, QString(), 0, QPointF());
|
||
update();
|
||
}
|
||
}
|
||
|
||
void EditorCanvas::mouseMoveEvent(QMouseEvent* e) {
|
||
const QPointF wp = viewToWorld(e->position());
|
||
emit hoveredWorldPosChanged(wp);
|
||
int z = -1;
|
||
if (!m_depthAbsPath.isEmpty()) {
|
||
if (m_depthDirty) {
|
||
m_depthDirty = false;
|
||
QImage img(m_depthAbsPath);
|
||
m_depthImage8 = img.isNull() ? QImage() : img.convertToFormat(QImage::Format_Grayscale8);
|
||
}
|
||
if (!m_depthImage8.isNull()) {
|
||
const int xi = static_cast<int>(std::floor(wp.x()));
|
||
const int yi = static_cast<int>(std::floor(wp.y()));
|
||
if (xi >= 0 && yi >= 0 && xi < m_depthImage8.width() && yi < m_depthImage8.height()) {
|
||
z = static_cast<int>(m_depthImage8.constScanLine(yi)[xi]);
|
||
}
|
||
}
|
||
}
|
||
emit hoveredWorldPosDepthChanged(wp, z);
|
||
|
||
if (m_presentationPreviewMode) {
|
||
const int h = hitTestEntity(wp);
|
||
if (h != m_presHoverEntityIndex) {
|
||
m_presHoverEntityIndex = h;
|
||
updateCursor();
|
||
update();
|
||
}
|
||
if (h >= 0) {
|
||
if (m_presHoverTimer && !m_presHoverTimer->isActive()) {
|
||
m_presHoverTimer->start();
|
||
}
|
||
} else if (m_presHoverTimer) {
|
||
m_presHoverTimer->stop();
|
||
m_presHoverPhase = 0.0;
|
||
}
|
||
}
|
||
|
||
if (!m_dragging) {
|
||
QWidget::mouseMoveEvent(e);
|
||
return;
|
||
}
|
||
|
||
const QPointF cur = e->position();
|
||
const QPointF deltaView = cur - m_lastMouseView;
|
||
m_lastMouseView = cur;
|
||
|
||
if (m_pendingDragging && !m_presentationPreviewMode && m_pendingPolyWorld.size() >= 3) {
|
||
const QPointF curWorld = viewToWorld(e->position());
|
||
const QPointF delta = curWorld - m_pendingLastMouseWorld;
|
||
m_pendingLastMouseWorld = curWorld;
|
||
if (m_pendingDragWhole) {
|
||
for (auto& pt : m_pendingPolyWorld) {
|
||
pt += delta;
|
||
}
|
||
} else if (m_pendingDragVertex >= 0 && m_pendingDragVertex < m_pendingPolyWorld.size()) {
|
||
m_pendingPolyWorld[m_pendingDragVertex] += delta;
|
||
}
|
||
update();
|
||
return;
|
||
}
|
||
|
||
if (m_tool == Tool::CreateEntity && m_drawingEntity) {
|
||
const QPointF w = viewToWorld(cur);
|
||
if (m_strokeWorld.isEmpty()) {
|
||
m_strokeWorld.push_back(w);
|
||
update();
|
||
return;
|
||
}
|
||
const QPointF last = m_strokeWorld.last();
|
||
const qreal dx = w.x() - last.x();
|
||
const qreal dy = w.y() - last.y();
|
||
// 简单抽样：world 距离至少 1.5 像素才记录，避免点过密
|
||
if ((dx * dx + dy * dy) >= (1.5 * 1.5)) {
|
||
m_strokeWorld.push_back(w);
|
||
update();
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (m_draggingEntity && m_selectedEntity >= 0 && m_selectedEntity < m_entities.size()) {
|
||
const QPointF worldPos = viewToWorld(cur);
|
||
auto& ent = m_entities[m_selectedEntity];
|
||
const QPointF newOrigin = worldPos - m_entityDragOffsetOriginWorld;
|
||
QPointF delta = newOrigin - ent.animatedOriginWorld;
|
||
|
||
// 轴约束：只允许沿 X 或 Y 平移（world 坐标）
|
||
if (m_dragMode == DragMode::AxisX) {
|
||
delta.setY(0.0);
|
||
} else if (m_dragMode == DragMode::AxisY) {
|
||
delta.setX(0.0);
|
||
}
|
||
|
||
// 约束到背景范围内（若有背景），按“预览变换后”的包围盒约束
|
||
const QRectF bg = worldRectOfBackground();
|
||
if (!bg.isNull()) {
|
||
const QRectF moved = transformedRectByScaleAndTranslate(
|
||
m_dragPreviewActive ? m_dragRectBase : ent.rect,
|
||
m_dragPreviewActive ? m_dragCentroidBase : ent.rect.center(),
|
||
m_dragPreviewActive ? m_dragScaleRatio : 1.0,
|
||
(m_dragPreviewActive ? m_dragDelta : QPointF(0, 0)) + delta);
|
||
QPointF d = delta;
|
||
if (moved.left() < bg.left()) d.setX(d.x() + (bg.left() - moved.left()));
|
||
if (moved.top() < bg.top()) d.setY(d.y() + (bg.top() - moved.top()));
|
||
if (moved.right() > bg.right()) d.setX(d.x() - (moved.right() - bg.right()));
|
||
if (moved.bottom() > bg.bottom()) d.setY(d.y() - (moved.bottom() - bg.bottom()));
|
||
delta = d;
|
||
}
|
||
|
||
// 轻量：仅更新增量参数与原点，不逐点修改 polygonWorld
|
||
if (m_dragPreviewActive) {
|
||
m_dragDelta += delta;
|
||
}
|
||
ent.animatedOriginWorld += delta;
|
||
|
||
// 拖动中实时按深度图更新 z 与距离缩放（近大远小）
|
||
// 但不必每个鼠标事件都重算：位置平移满帧跟手；深度/距离缩放重算较重，节流到 ~30Hz。
|
||
const qint64 nowMs = m_previewEmitTimer.elapsed();
|
||
if (nowMs - m_lastDepthScaleRecalcMs >= 33) {
|
||
m_lastDepthScaleRecalcMs = nowMs;
|
||
|
||
if (!m_depthAbsPath.isEmpty() && m_depthDirty) {
|
||
m_depthDirty = false;
|
||
QImage img(m_depthAbsPath);
|
||
m_depthImage8 = img.isNull() ? QImage() : img.convertToFormat(QImage::Format_Grayscale8);
|
||
}
|
||
if (!m_depthImage8.isNull()) {
|
||
// 深度采样点：使用“预览质心的平移后位置”
|
||
const QPointF c = (m_dragPreviewActive ? (m_dragCentroidBase + m_dragDelta) : ent.animatedOriginWorld);
|
||
const int depthZ = sampleDepthAtPoint(m_depthImage8, c);
|
||
ent.depth = depthZ;
|
||
|
||
const double ds01 = depthToScale01(depthZ);
|
||
ent.animatedDepthScale01 = ds01;
|
||
const double newScale =
|
||
distanceScaleFromDepth01(ds01, ent.distanceScaleCalibMult) * ent.userScale;
|
||
ent.visualScale = newScale;
|
||
if (m_dragPreviewActive) {
|
||
m_dragScaleRatio = std::clamp(newScale / std::max(1e-6, m_dragScaleBase), 0.02, 50.0);
|
||
}
|
||
}
|
||
}
|
||
// 低频预览信号：用于属性面板同步，不做树联动等重操作
|
||
// 属性面板/状态预览：按 30Hz 刷新即可，拖动视觉仍满帧跟手
|
||
if (nowMs - m_lastPreviewEmitMs >= 33) {
|
||
m_lastPreviewEmitMs = nowMs;
|
||
emit selectedEntityPreviewChanged(ent.id, ent.depth, ent.animatedOriginWorld);
|
||
}
|
||
update();
|
||
return;
|
||
}
|
||
|
||
// 平移画布
|
||
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());
|
||
}
|
||
m_pan += deltaView;
|
||
update();
|
||
return;
|
||
}
|
||
}
|
||
|
||
void EditorCanvas::mouseReleaseEvent(QMouseEvent* e) {
|
||
if (e->button() == Qt::LeftButton || e->button() == Qt::MiddleButton) {
|
||
if (m_presentationPreviewMode && e->button() == Qt::LeftButton) {
|
||
if (m_presBgPanSession && m_presBgDragDist < 8.0) {
|
||
clearPresentationEntityFocus();
|
||
}
|
||
m_presBgPanSession = false;
|
||
m_presBgDragDist = 0.0;
|
||
}
|
||
if (m_tool == Tool::CreateEntity && e->button() == Qt::LeftButton && m_drawingEntity) {
|
||
m_dragging = false;
|
||
m_drawingEntity = false;
|
||
updateCursor();
|
||
|
||
if (m_entityCreateSegmentMode == EntityCreateSegmentMode::Manual) {
|
||
if (m_strokeWorld.size() >= kMinStrokePointsManual) {
|
||
setPendingEntityPolygonWorld(m_strokeWorld);
|
||
}
|
||
} else if (m_entityCreateSegmentMode == EntityCreateSegmentMode::Snap) {
|
||
if (m_strokeWorld.size() >= kMinStrokePointsManual) {
|
||
ensurePixmapLoaded();
|
||
const QVector<QPointF> snapped = snapStrokeToEdges(m_strokeWorld, m_bgImage, 6);
|
||
setPendingEntityPolygonWorld(snapped);
|
||
}
|
||
} else if (m_strokeWorld.size() >= kMinStrokePointsSam) {
|
||
ensurePixmapLoaded();
|
||
QByteArray cropPng;
|
||
QByteArray ovPng;
|
||
QPointF cropOrigin;
|
||
QJsonArray pts;
|
||
QJsonArray labs;
|
||
QJsonArray box;
|
||
if (buildSamSegmentPayloadFromStroke(m_strokeWorld, m_bgImage, cropPng, ovPng, cropOrigin, pts, labs, box)) {
|
||
emit requestSamSegment(cropPng, ovPng, cropOrigin, pts, labs, box);
|
||
}
|
||
}
|
||
m_strokeWorld.clear();
|
||
update();
|
||
return;
|
||
}
|
||
|
||
if (m_draggingEntity && m_selectedEntity >= 0 && m_selectedEntity < m_entities.size() && e->button() == Qt::LeftButton) {
|
||
const auto& ent = m_entities[m_selectedEntity];
|
||
|
||
// 关键：提交“平移量”必须与缩放无关。
|
||
// 拖动过程中可能实时按深度重算 visualScale（导致 rect/topLeft 随缩放变化），
|
||
// 因此不能用 rect.topLeft 差值作为移动 delta，否则松手会错位。
|
||
const QPointF delta = ent.animatedOriginWorld - m_entityDragStartAnimatedOrigin;
|
||
|
||
bool sentMove = false;
|
||
if (!ent.id.isEmpty() && (!qFuzzyIsNull(delta.x()) || !qFuzzyIsNull(delta.y()))) {
|
||
emit requestMoveEntity(ent.id, delta);
|
||
sentMove = true;
|
||
}
|
||
if (!sentMove && !ent.id.isEmpty()) {
|
||
const QPointF origin =
|
||
ent.polygonWorld.isEmpty() ? ent.rect.center() : entity_cutout::polygonCentroid(ent.polygonWorld);
|
||
emit selectedEntityChanged(true, ent.id, ent.depth, origin);
|
||
}
|
||
}
|
||
|
||
m_dragging = false;
|
||
if (m_pendingDragging && e->button() == Qt::LeftButton) {
|
||
m_pendingDragging = false;
|
||
m_pendingDragWhole = false;
|
||
m_pendingDragVertex = -1;
|
||
}
|
||
if (m_draggingEntity) {
|
||
emit entityDragActiveChanged(false);
|
||
}
|
||
m_draggingEntity = false;
|
||
m_dragPreviewActive = false;
|
||
m_dragMode = DragMode::None;
|
||
updateCursor();
|
||
}
|
||
QWidget::mouseReleaseEvent(e);
|
||
}
|
||
|
||
void EditorCanvas::wheelEvent(QWheelEvent* e) {
|
||
if (m_tool != Tool::Zoom && !(e->modifiers() & Qt::ControlModifier)) {
|
||
// 默认仍允许滚轮缩放：不强制用户切换工具
|
||
//（若你希望仅在 Zoom 工具下才缩放，可在此 return）
|
||
}
|
||
|
||
const QPointF cursorView = e->position();
|
||
const QPointF beforeWorld = viewToWorld(cursorView);
|
||
|
||
// 约定：滚轮一步约 15°，这里做平滑指数缩放
|
||
const qreal steps = e->angleDelta().y() / 120.0;
|
||
const qreal factor = std::pow(1.15, steps);
|
||
|
||
const qreal newScale = std::clamp(m_scale * factor, 0.05, 50.0);
|
||
if (qFuzzyCompare(newScale, m_scale)) {
|
||
return;
|
||
}
|
||
m_scale = newScale;
|
||
|
||
// 让“光标指向的 world 点”缩放后仍落在光标处
|
||
const QPointF afterView = worldToView(beforeWorld);
|
||
m_pan += (cursorView - afterView);
|
||
update();
|
||
e->accept();
|
||
}
|
||
|
||
void EditorCanvas::keyPressEvent(QKeyEvent* e) {
|
||
if (m_presentationPreviewMode && e->key() == Qt::Key_Escape) {
|
||
clearPresentationEntityFocus();
|
||
e->accept();
|
||
return;
|
||
}
|
||
if (!m_presentationPreviewMode && m_pendingPolyWorld.size() >= 3) {
|
||
if (e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter) {
|
||
emit requestFinalizePendingEntity(m_pendingPolyWorld);
|
||
e->accept();
|
||
return;
|
||
}
|
||
if (e->key() == Qt::Key_Escape) {
|
||
clearPendingEntityPolygon();
|
||
e->accept();
|
||
return;
|
||
}
|
||
}
|
||
QWidget::keyPressEvent(e);
|
||
}
|
||
|