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

update

Browse Source
This commit is contained in:
DingVero
2026-05-14 13:30:06 +08:00
parent 974946cee4
commit e43171521d
91 changed files with 10485 additions and 3254 deletions
Download Patch File Download Diff File Expand all files Collapse all files
client/core/CMakeLists.txt
+59
View File
@@ -1,11 +1,21 @@
# 模块：domain、persistence、workspace、depth、animation（时间采样）
set(CORE_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
option(LT_WITH_VIPS "Use libvips for GB-scale PNG/JPEG (libvips-dev / pkg-config vips)" ON)
set(CORE_SOURCES
${CORE_ROOT}/domain/Project.cpp
${CORE_ROOT}/image/ImageFileLoader.cpp
${CORE_ROOT}/large_image/VipsBackend.cpp
${CORE_ROOT}/workspace/ProjectWorkspace.cpp
${CORE_ROOT}/persistence/PersistentBinaryObject.cpp
${CORE_ROOT}/persistence/AnimationBinary.cpp
${CORE_ROOT}/persistence/EntityPayloadBinary.cpp
${CORE_ROOT}/persistence/JsonFileAtomic.cpp
${CORE_ROOT}/persistence/EntityBundleStore.cpp
${CORE_ROOT}/persistence/AnimationBundleStore.cpp
${CORE_ROOT}/persistence/AsyncProjectWriter.cpp
${CORE_ROOT}/animation/AnimationEvaluator.cpp
${CORE_ROOT}/animation/AnimationSampling.cpp
${CORE_ROOT}/depth/DepthService.cpp
${CORE_ROOT}/net/ModelServerClient.cpp
@@ -17,11 +27,20 @@ set(CORE_SOURCES
)
set(CORE_HEADERS
${CORE_ROOT}/image/ImageDecodeConfig.h
${CORE_ROOT}/image/ImageFileLoader.h
${CORE_ROOT}/large_image/VipsBackend.h
${CORE_ROOT}/domain/EntityIntro.h
${CORE_ROOT}/domain/Project.h
${CORE_ROOT}/workspace/ProjectWorkspace.h
${CORE_ROOT}/persistence/PersistentBinaryObject.h
${CORE_ROOT}/persistence/AnimationBinary.h
${CORE_ROOT}/persistence/EntityPayloadBinary.h
${CORE_ROOT}/persistence/JsonFileAtomic.h
${CORE_ROOT}/persistence/EntityBundleStore.h
${CORE_ROOT}/persistence/AnimationBundleStore.h
${CORE_ROOT}/persistence/AsyncProjectWriter.h
${CORE_ROOT}/animation/AnimationEvaluator.h
${CORE_ROOT}/animation/AnimationSampling.h
${CORE_ROOT}/depth/DepthService.h
${CORE_ROOT}/net/ModelServerClient.h
@@ -47,4 +66,44 @@ target_link_libraries(core
${QT_PACKAGE}::Core
${QT_PACKAGE}::Gui
${QT_PACKAGE}::Network
${QT_PACKAGE}::Concurrent
)
# libvips：优先 IMPORTED_TARGET；失败则用 pkg-config 变量（部分环境下更稳）
set(LT_VIPS_ENABLED OFF)
if(LT_WITH_VIPS)
find_package(PkgConfig QUIET)
if(PKG_CONFIG_FOUND)
pkg_check_modules(VIPS_PC IMPORTED_TARGET vips)
if(TARGET PkgConfig::VIPS_PC)
target_compile_definitions(core PRIVATE LT_HAVE_VIPS=1)
target_link_libraries(core PUBLIC PkgConfig::VIPS_PC)
set(LT_VIPS_ENABLED ON)
message(STATUS "libvips: enabled via IMPORTED_TARGET (LT_HAVE_VIPS)")
else()
pkg_check_modules(VIPS_LEGACY QUIET vips)
if(VIPS_LEGACY_FOUND)
target_compile_definitions(core PRIVATE LT_HAVE_VIPS=1)
target_include_directories(core PRIVATE ${VIPS_LEGACY_INCLUDE_DIRS})
target_link_directories(core PUBLIC ${VIPS_LEGACY_LIBRARY_DIRS})
target_link_libraries(core PUBLIC ${VIPS_LEGACY_LIBRARIES})
if(VIPS_LEGACY_CFLAGS_OTHER)
separate_arguments(_vips_cflags UNIX_COMMAND "${VIPS_LEGACY_CFLAGS_OTHER}")
target_compile_options(core PRIVATE ${_vips_cflags})
endif()
set(LT_VIPS_ENABLED ON)
message(STATUS "libvips: enabled via pkg-config variables (LT_HAVE_VIPS)")
endif()
endif()
endif()
endif()
if(LT_WITH_VIPS AND NOT LT_VIPS_ENABLED)
message(
WARNING
"未找到 libvips（无 pkg-config 模块 vips），已关闭 LT_HAVE_VIPS，大图仍走 Qt 解码。\n"
" Debian/Ubuntu: sudo apt install pkg-config libvips-dev\n"
" Fedora: sudo dnf install pkgconf-pkg-config vips-devel\n"
" 安装后终端执行: pkg-config --modversion vips （应打印版本号）\n"
" 若已安装仍失败: export PKG_CONFIG_PATH=\"/usr/lib/x86_64-linux-gnu/pkgconfig:\$PKG_CONFIG_PATH\""
)
endif()
client/core/animation/AnimationEvaluator.cpp
+180
View File
@@ -0,0 +1,180 @@
#include "animation/AnimationEvaluator.h"
#include <algorithm>
namespace core {
namespace {
QVector<Project::AnimationKey> sortedKeys(const QVector<Project::AnimationKey>& keys) {
QVector<Project::AnimationKey> out = keys;
std::sort(out.begin(), out.end(), [](const auto& a, const auto& b) { return a.frame < b.frame; });
return out;
}
bool sampleBool(const QVector<Project::AnimationKey>& keys, int frame, bool fallback) {
auto sorted = sortedKeys(keys);
bool out = fallback;
for (const auto& k : sorted) {
if (k.frame <= frame) out = k.boolValue;
else break;
}
return out;
}
QString sampleString(const QVector<Project::AnimationKey>& keys, int frame, const QString& fallback = {}) {
auto sorted = sortedKeys(keys);
QString out = fallback;
for (const auto& k : sorted) {
if (k.frame <= frame && !k.stringValue.isEmpty()) out = k.stringValue;
else if (k.frame > frame) break;
}
return out;
}
QByteArray sampleBytes(const QVector<Project::AnimationKey>& keys, int frame, const QByteArray& fallback = {}) {
auto sorted = sortedKeys(keys);
QByteArray out = fallback;
for (const auto& k : sorted) {
if (k.frame <= frame && !k.bytesValue.isEmpty()) out = k.bytesValue;
else if (k.frame > frame) break;
}
return out;
}
double sampleDouble(const QVector<Project::AnimationKey>& keys,
int frame,
double fallback,
Project::AnimationInterpolation interpolation) {
auto sorted = sortedKeys(keys);
if (sorted.isEmpty()) return fallback;
if (interpolation == Project::AnimationInterpolation::Hold) {
double out = fallback;
for (const auto& k : sorted) {
if (k.frame <= frame) out = k.numberValue;
else break;
}
return out;
}
if (frame <= sorted.front().frame) return sorted.front().numberValue;
if (frame >= sorted.back().frame) return sorted.back().numberValue;
for (int i = 0; i + 1 < sorted.size(); ++i) {
const auto& a = sorted[i];
const auto& b = sorted[i + 1];
if (frame >= a.frame && frame <= b.frame) {
if (a.frame == b.frame) return a.numberValue;
const double t = double(frame - a.frame) / double(b.frame - a.frame);
return a.numberValue + (b.numberValue - a.numberValue) * t;
}
}
return sorted.back().numberValue;
}
QPointF sampleVec2(const QVector<Project::AnimationKey>& keys,
int frame,
const QPointF& fallback,
Project::AnimationInterpolation interpolation) {
auto sorted = sortedKeys(keys);
if (sorted.isEmpty()) return fallback;
if (interpolation == Project::AnimationInterpolation::Hold) {
QPointF out = fallback;
for (const auto& k : sorted) {
if (k.frame <= frame) out = k.vec2Value;
else break;
}
return out;
}
if (frame <= sorted.front().frame) return sorted.front().vec2Value;
if (frame >= sorted.back().frame) return sorted.back().vec2Value;
for (int i = 0; i + 1 < sorted.size(); ++i) {
const auto& a = sorted[i];
const auto& b = sorted[i + 1];
if (frame >= a.frame && frame <= b.frame) {
if (a.frame == b.frame) return a.vec2Value;
const double t = double(frame - a.frame) / double(b.frame - a.frame);
return QPointF(a.vec2Value.x() + (b.vec2Value.x() - a.vec2Value.x()) * t,
a.vec2Value.y() + (b.vec2Value.y() - a.vec2Value.y()) * t);
}
}
return sorted.back().vec2Value;
}
} // namespace
AnimationSample evaluateAnimation(const Project::Animation& animation, int frame) {
AnimationSample out;
const int f = animation.loop && animation.lengthFrames > 0
? (std::max(0, frame) % animation.lengthFrames)
: std::clamp(frame, 0, std::max(0, animation.lengthFrames - 1));
for (const auto& t : animation.tracks) {
if (t.targetId.isEmpty() || t.keys.isEmpty()) continue;
if (t.targetKind == Project::AnimationTargetKind::Entity) {
switch (t.property) {
case Project::AnimationProperty::Position:
out.entityPosition.insert(t.targetId, sampleVec2(t.keys, f, QPointF(), t.interpolation));
break;
case Project::AnimationProperty::UserScale:
out.entityUserScale.insert(t.targetId, sampleDouble(t.keys, f, 1.0, t.interpolation));
break;
case Project::AnimationProperty::DepthScale:
out.entityDepthScale01.insert(t.targetId, sampleDouble(t.keys, f, 0.5, t.interpolation));
break;
case Project::AnimationProperty::Sprite:
// 贴图仅支持二进制 PNG bytes（不兼容路径关键帧）。
if (t.valueType == Project::AnimationValueType::PngBytes) {
out.entitySpritePng.insert(t.targetId, sampleBytes(t.keys, f));
}
break;
case Project::AnimationProperty::Visibility:
out.entityVisibility.insert(t.targetId, sampleBool(t.keys, f, true));
break;
case Project::AnimationProperty::Priority:
out.entityPriority.insert(t.targetId, sampleDouble(t.keys, f, 1.0, t.interpolation));
break;
default:
break;
}
} else if (t.targetKind == Project::AnimationTargetKind::Tool) {
if (t.property == Project::AnimationProperty::Position) {
out.toolPosition.insert(t.targetId, sampleVec2(t.keys, f, QPointF(), t.interpolation));
} else if (t.property == Project::AnimationProperty::Visibility) {
out.toolVisibility.insert(t.targetId, sampleBool(t.keys, f, true));
} else if (t.property == Project::AnimationProperty::Priority) {
out.toolPriority.insert(t.targetId, sampleDouble(t.keys, f, 10.0, t.interpolation));
}
} else if (t.targetKind == Project::AnimationTargetKind::Camera) {
if (t.property == Project::AnimationProperty::Position) {
out.cameraPosition.insert(t.targetId, sampleVec2(t.keys, f, QPointF(), t.interpolation));
} else if (t.property == Project::AnimationProperty::CameraScale) {
out.cameraScale.insert(t.targetId, sampleDouble(t.keys, f, 1.0, t.interpolation));
}
}
}
return out;
}
QVector<Project::Entity::ImageFrame> spriteFramesForEntity(const Project::Animation& animation,
const QString& entityId) {
QVector<Project::Entity::ImageFrame> out;
for (const auto& t : animation.tracks) {
if (t.targetKind != Project::AnimationTargetKind::Entity ||
t.targetId != entityId ||
t.property != Project::AnimationProperty::Sprite) {
continue;
}
out.reserve(out.size() + t.keys.size());
for (const auto& k : t.keys) {
if (t.valueType == Project::AnimationValueType::PngBytes) {
if (!k.bytesValue.isEmpty()) {
out.push_back(Project::Entity::ImageFrame{k.frame, QString()});
}
} else if (t.valueType == Project::AnimationValueType::ImagePath) {
// 旧格式：不再支持路径型 sprite 关键帧（按“无/回退默认贴图”处理）
}
}
}
std::sort(out.begin(), out.end(), [](const auto& a, const auto& b) { return a.frame < b.frame; });
return out;
}
} // namespace core
client/core/animation/AnimationEvaluator.h
+31
View File
@@ -0,0 +1,31 @@
#pragma once
#include "domain/Project.h"
#include <QHash>
#include <QPointF>
#include <QString>
namespace core {
struct AnimationSample {
QHash<QString, QPointF> entityPosition;
QHash<QString, double> entityUserScale;
QHash<QString, double> entityDepthScale01;
QHash<QString, QByteArray> entitySpritePng;
QHash<QString, bool> entityVisibility;
QHash<QString, double> entityPriority;
QHash<QString, QPointF> toolPosition;
QHash<QString, bool> toolVisibility;
QHash<QString, double> toolPriority;
QHash<QString, QPointF> cameraPosition;
QHash<QString, double> cameraScale;
};
[[nodiscard]] AnimationSample evaluateAnimation(const Project::Animation& animation, int frame);
[[nodiscard]] QVector<Project::Entity::ImageFrame> spriteFramesForEntity(const Project::Animation& animation,
const QString& entityId);
} // namespace core
client/core/domain/Project.h
+80 -92
View File
@@ -2,9 +2,11 @@
#include "domain/EntityIntro.h"
#include <QRect>
#include <QString>
#include <QPointF>
#include <QHash>
#include <QByteArray>
#include <QVector>
#include <algorithm>
@@ -59,9 +61,16 @@ public:
bool blackholeVisible = true;
// 背景空缺修复方案：copy_background / use_original_background / model_inpaint（预留）
QString blackholeResolvedBy;
/// 修复结果相对项目根路径；与 blackholeOverlayRect 一起用于画布叠加，不修改 background 原图
QString blackholeOverlayPath;
/// 覆盖层在背景图坐标系中的像素矩形；宽或高 <=0 表示无
QRect blackholeOverlayRect;
QPointF originWorld;
int depth = 0; // 0..255
int priority = 1; // 0=背景之上最底层；越大越靠上（同优先级再按距离缩放/深度）
QString imagePath; // 相对路径，例如 "assets/entities/entity-1.png"
QByteArray defaultImagePng; // 默认贴图 PNG bytes（不兼容旧路径工程时此为唯一来源）
QByteArray runtimeImagePng; // 运行时求值后的 PNG bytes（不序列化）
QPointF imageTopLeftWorld; // 贴图左上角 world 坐标
// 人为整体缩放，与深度驱动的距离缩放相乘（画布中 visualScale = distanceScale * userScale；
// distanceScale 在有 distanceScaleCalibMult 时为 (0.5+depth01)/calib，使抠图处为 1.0）
@@ -73,8 +82,7 @@ public:
// 约定：对话气泡等 UI 元素默认打开。
bool ignoreDistanceScale = false;
// 父子关系：当 parentId 非空时，实体会保持相对父实体的偏移（world 坐标）。
// parentOffsetWorld 表示「childOrigin - parentOrigin」在 world 中的偏移。
// 父子关系：在「原点已与形心对齐」时，parentOffsetWorld 表示子形心相对父形心的世界偏移；否则为子原点相对父原点的偏移（与求值器一致）。
QString parentId;
QPointF parentOffsetWorld;
@@ -97,9 +105,6 @@ public:
// v2：project.json 仅存 id + payload，几何与动画在 entityPayloadPath（.hfe）中。
QString entityPayloadPath; // 例如 "assets/entities/entity-1.hfe"
// 仅打开 v1 项目时由 JSON 的 animationBundle 填入，用于合并旧 .anim；保存 v2 前应为空。
QString legacyAnimSidecarPath;
QVector<KeyframeVec2> locationKeys;
QVector<KeyframeFloat01> depthScaleKeys;
QVector<KeyframeDouble> userScaleKeys;
@@ -128,6 +133,7 @@ public:
// 基准位置（无关键帧时使用）
QPointF originWorld;
int priority = 10; // 默认高于实体（实体默认 1）；越大越靠上
QVector<Entity::KeyframeVec2> locationKeys;
// 可见性轨道：布尔关键帧（显示/隐藏）；渲染时会被解释为“10 帧淡入淡出”。
@@ -166,96 +172,79 @@ public:
void setActiveCameraId(const QString& id) { m_activeCameraId = id; }
const QString& activeCameraId() const { return m_activeCameraId; }
// —— 动画系统（Blender/NLA 风格简化版，工程级）——
struct AnimationClip {
// —— 动画系统（Godot AnimationPlayer 风格简化版）——
enum class AnimationTargetKind { Entity, Tool, Camera };
enum class AnimationProperty { Position, UserScale, Sprite, Visibility, DepthScale, CameraScale, Priority };
enum class AnimationValueType { Vec2, Double, Bool, ImagePath, PngBytes };
enum class AnimationInterpolation { Hold, Linear };
struct AnimationKey {
int frame = 0;
QPointF vec2Value;
double numberValue = 0.0;
bool boolValue = true;
QString stringValue;
QByteArray bytesValue;
};
struct AnimationTrack {
QString id;
AnimationTargetKind targetKind = AnimationTargetKind::Entity;
QString targetId;
AnimationProperty property = AnimationProperty::Position;
AnimationValueType valueType = AnimationValueType::Vec2;
AnimationInterpolation interpolation = AnimationInterpolation::Linear;
QVector<AnimationKey> keys;
};
struct Animation {
QString id;
QString name;
// Entity channels (keyed by entity id)
QHash<QString, QVector<Entity::KeyframeVec2>> entityLocationKeys;
QHash<QString, QVector<Entity::KeyframeDouble>> entityUserScaleKeys;
QHash<QString, QVector<Entity::ImageFrame>> entityImageFrames;
QHash<QString, QVector<ToolKeyframeBool>> entityVisibilityKeys;
// Tool channels (keyed by tool id)
QHash<QString, QVector<Entity::KeyframeVec2>> toolLocationKeys;
QHash<QString, QVector<ToolKeyframeBool>> toolVisibilityKeys;
QHash<QString, QVector<Entity::KeyframeVec2>> cameraLocationKeys;
QHash<QString, QVector<Entity::KeyframeDouble>> cameraScaleKeys;
QString payloadPath; // 例如 "assets/animations/animation-1.hfa"
int fps = 30;
int lengthFrames = kClipFixedFrames;
bool loop = true;
QVector<AnimationTrack> tracks;
};
struct NlaStrip {
void setAnimations(const QVector<Animation>& animations) { m_animations = animations; }
const QVector<Animation>& animations() const { return m_animations; }
void setActiveAnimationId(const QString& id) { m_activeAnimationId = id; }
const QString& activeAnimationId() const { return m_activeAnimationId; }
const Animation* findAnimationById(const QString& id) const {
for (const auto& a : m_animations) {
if (a.id == id) return &a;
}
return nullptr;
}
Animation* findAnimationById(const QString& id) {
for (auto& a : m_animations) {
if (a.id == id) return &a;
}
return nullptr;
}
const Animation* activeAnimationOrNull() const {
const Animation* a = findAnimationById(m_activeAnimationId);
if (a) return a;
return m_animations.isEmpty() ? nullptr : &m_animations.front();
}
Animation* activeAnimationOrNull() {
Animation* a = findAnimationById(m_activeAnimationId);
if (a) return a;
return m_animations.isEmpty() ? nullptr : &m_animations.front();
}
struct PresentationHotspot {
QString id;
QString clipId;
int startSlot = 0; // slot index; 1 slot = kClipFixedFrames frames
int slotLen = 1; // currently fixed to 1; reserved for future
bool enabled = true;
bool muted = false;
QPointF centerWorld;
QString targetAnimationId;
};
struct NlaTrack {
QString id;
QString name;
bool muted = false;
bool solo = false;
QVector<NlaStrip> strips;
};
struct AnimationScheme {
QString id;
QString name;
QVector<NlaTrack> tracks;
};
void setAnimationClips(const QVector<AnimationClip>& clips) { m_clips = clips; }
const QVector<AnimationClip>& animationClips() const { return m_clips; }
void setAnimationSchemes(const QVector<AnimationScheme>& schemes) { m_schemes = schemes; }
const QVector<AnimationScheme>& animationSchemes() const { return m_schemes; }
void setActiveSchemeId(const QString& id) { m_activeSchemeId = id; }
const QString& activeSchemeId() const { return m_activeSchemeId; }
void setSelectedStripId(const QString& id) { m_selectedStripId = id; }
const QString& selectedStripId() const { return m_selectedStripId; }
const AnimationScheme* findSchemeById(const QString& id) const {
for (const auto& s : m_schemes) {
if (s.id == id) return &s;
}
return nullptr;
}
AnimationScheme* findSchemeById(const QString& id) {
for (auto& s : m_schemes) {
if (s.id == id) return &s;
}
return nullptr;
}
const AnimationClip* findClipById(const QString& id) const {
for (const auto& c : m_clips) {
if (c.id == id) return &c;
}
return nullptr;
}
AnimationClip* findClipById(const QString& id) {
for (auto& c : m_clips) {
if (c.id == id) return &c;
}
return nullptr;
}
const AnimationScheme* activeSchemeOrNull() const {
const AnimationScheme* s = findSchemeById(m_activeSchemeId);
if (s) return s;
return m_schemes.isEmpty() ? nullptr : &m_schemes.front();
}
AnimationScheme* activeSchemeOrNull() {
AnimationScheme* s = findSchemeById(m_activeSchemeId);
if (s) return s;
return m_schemes.isEmpty() ? nullptr : &m_schemes.front();
}
void setPresentationHotspots(const QVector<PresentationHotspot>& v) { m_presentationHotspots = v; }
const QVector<PresentationHotspot>& presentationHotspots() const { return m_presentationHotspots; }
QVector<PresentationHotspot>& presentationHotspotsRef() { return m_presentationHotspots; }
private:
QString m_name;
@@ -271,10 +260,9 @@ private:
QVector<Camera> m_cameras;
QString m_activeCameraId;
QVector<AnimationClip> m_clips;
QVector<AnimationScheme> m_schemes;
QString m_activeSchemeId;
QString m_selectedStripId;
QVector<Animation> m_animations;
QString m_activeAnimationId;
QVector<PresentationHotspot> m_presentationHotspots;
};
} // namespace core
client/core/eval/ProjectEvaluator.cpp
+65 -169
View File
@@ -1,8 +1,10 @@
#include "eval/ProjectEvaluator.h"
#include "animation/AnimationEvaluator.h"
#include "animation/AnimationSampling.h"
#include <algorithm>
#include <cmath>
#include <unordered_set>
namespace core::eval {
@@ -15,68 +17,6 @@ struct NodeRef {
int index = -1;
};
QPointF sampledOriginForEntity(const core::Project::Entity& e,
const core::Project::AnimationClip* clipOrNull,
int localFrame) {
if (clipOrNull && clipOrNull->entityLocationKeys.contains(e.id)) {
const auto& keys = clipOrNull->entityLocationKeys.value(e.id);
return core::sampleLocation(keys, localFrame, e.originWorld, core::KeyInterpolation::Linear);
}
return core::sampleLocation(e.locationKeys, localFrame, e.originWorld, core::KeyInterpolation::Linear);
}
QPointF sampledRelativeForEntity(const core::Project::Entity& e,
const core::Project::AnimationClip* clipOrNull,
int localFrame) {
if (clipOrNull && clipOrNull->entityLocationKeys.contains(e.id)) {
const auto& keys = clipOrNull->entityLocationKeys.value(e.id);
return core::sampleLocation(keys, localFrame, e.parentOffsetWorld, core::KeyInterpolation::Linear);
}
return core::sampleLocation(e.locationKeys, localFrame, e.parentOffsetWorld, core::KeyInterpolation::Linear);
}
QPointF sampledOriginForTool(const core::Project::Tool& t,
const core::Project::AnimationClip* clipOrNull,
int localFrame) {
if (clipOrNull && clipOrNull->toolLocationKeys.contains(t.id)) {
const auto& keys = clipOrNull->toolLocationKeys.value(t.id);
return core::sampleLocation(keys, localFrame, t.originWorld, core::KeyInterpolation::Linear);
}
return core::sampleLocation(t.locationKeys, localFrame, t.originWorld, core::KeyInterpolation::Linear);
}
QPointF sampledCenterForCamera(const core::Project::Camera& c,
const core::Project::AnimationClip* clipOrNull,
int localFrame) {
if (clipOrNull && clipOrNull->cameraLocationKeys.contains(c.id)) {
const auto& keys = clipOrNull->cameraLocationKeys.value(c.id);
return core::sampleLocation(keys, localFrame, c.centerWorld, core::KeyInterpolation::Linear);
}
return core::sampleLocation(c.locationKeys, localFrame, c.centerWorld, core::KeyInterpolation::Linear);
}
double sampledViewScaleForCamera(const core::Project::Camera& c,
const core::Project::AnimationClip* clipOrNull,
int localFrame) {
if (clipOrNull && clipOrNull->cameraScaleKeys.contains(c.id)) {
const auto& keys = clipOrNull->cameraScaleKeys.value(c.id);
if (!keys.isEmpty()) {
return core::sampleUserScale(keys, localFrame, c.viewScale, core::KeyInterpolation::Linear);
}
}
return core::sampleUserScale(c.scaleKeys, localFrame, c.viewScale, core::KeyInterpolation::Linear);
}
QPointF sampledRelativeForTool(const core::Project::Tool& t,
const core::Project::AnimationClip* clipOrNull,
int localFrame) {
if (clipOrNull && clipOrNull->toolLocationKeys.contains(t.id)) {
const auto& keys = clipOrNull->toolLocationKeys.value(t.id);
return core::sampleLocation(keys, localFrame, t.parentOffsetWorld, core::KeyInterpolation::Linear);
}
return core::sampleLocation(t.locationKeys, localFrame, t.parentOffsetWorld, core::KeyInterpolation::Linear);
}
struct VisKey {
int frame = 0;
bool value = true;
@@ -144,82 +84,10 @@ double opacityFromBoolKeys(const QVector<core::Project::ToolKeyframeBool>& keysR
return state ? 1.0 : 0.0;
}
struct StripEvalCtx {
const core::Project::AnimationScheme* scheme = nullptr;
const core::Project::NlaStrip* strip = nullptr;
const core::Project::AnimationClip* clip = nullptr;
int slot = 0;
int localFrame = 0; // 0..kClipFixedFrames-1
};
static const core::Project::NlaStrip* findStripById(const core::Project::AnimationScheme& scheme, const QString& id) {
if (id.isEmpty()) return nullptr;
for (const auto& tr : scheme.tracks) {
for (const auto& st : tr.strips) {
if (st.id == id) return &st;
}
}
return nullptr;
}
static bool trackIsEffectivelyMuted(const core::Project::AnimationScheme& scheme, const core::Project::NlaTrack& t) {
// 若有任意 solo=true，则只有 solo 的 track 生效（且仍受自身 muted 控制）
bool anySolo = false;
for (const auto& tr : scheme.tracks) {
if (tr.solo) {
anySolo = true;
break;
}
}
if (anySolo && !t.solo) {
return true;
}
return t.muted;
}
static const core::Project::NlaStrip* pickStripAtSlot(const core::Project::AnimationScheme& scheme, int slot) {
const core::Project::NlaStrip* chosen = nullptr;
for (const auto& tr : scheme.tracks) {
if (trackIsEffectivelyMuted(scheme, tr)) continue;
for (const auto& st : tr.strips) {
if (!st.enabled || st.muted) continue;
const int a = st.startSlot;
const int b = st.startSlot + std::max(1, st.slotLen);
if (slot >= a && slot < b) {
chosen = &st; // 轨道顺序靠后的覆盖靠前的（更接近“上层”）
}
}
}
return chosen;
}
static StripEvalCtx resolveStripCtx(const core::Project& project, int globalFrame) {
StripEvalCtx ctx;
const auto* scheme = project.activeSchemeOrNull();
if (!scheme) {
ctx.localFrame = std::max(0, globalFrame);
return ctx;
}
ctx.scheme = scheme;
const int g = std::max(0, globalFrame);
ctx.slot = g / core::Project::kClipFixedFrames;
ctx.localFrame = g % core::Project::kClipFixedFrames;
const core::Project::NlaStrip* st = findStripById(*scheme, project.selectedStripId());
// 若选中条带不覆盖当前 slot，则退回自动挑选
if (!st || ctx.slot < st->startSlot || ctx.slot >= (st->startSlot + std::max(1, st->slotLen)) || !st->enabled || st->muted) {
st = pickStripAtSlot(*scheme, ctx.slot);
}
ctx.strip = st;
if (st) {
ctx.clip = project.findClipById(st->clipId);
}
return ctx;
}
} // namespace
ResolvedProjectFrame evaluateAtFrame(const core::Project& project, int frame, int fadeFrames) {
ResolvedProjectFrame evaluateAtFrame(const core::Project& project, int frame, int fadeFrames,
const QString& animationId) {
ResolvedProjectFrame out;
const auto& ents = project.entities();
const auto& tools = project.tools();
@@ -228,9 +96,15 @@ ResolvedProjectFrame evaluateAtFrame(const core::Project& project, int frame, in
out.tools.reserve(tools.size());
out.cameras.reserve(cams.size());
const StripEvalCtx ctx = resolveStripCtx(project, frame);
const int localFrame = ctx.localFrame;
const core::Project::AnimationClip* clip = ctx.clip;
const int localFrame = std::max(0, frame);
const core::Project::Animation* activeAnimation = nullptr;
if (animationId.isEmpty()) {
activeAnimation = project.activeAnimationOrNull();
} else {
activeAnimation = project.findAnimationById(animationId);
}
const core::AnimationSample animSample =
activeAnimation ? core::evaluateAnimation(*activeAnimation, frame) : core::AnimationSample{};
QHash<QString, NodeRef> index;
index.reserve(ents.size() + tools.size());
@@ -262,8 +136,8 @@ ResolvedProjectFrame evaluateAtFrame(const core::Project& project, int frame, in
// cycle：降级为自身采样 origin
const NodeRef r = index.value(id);
QPointF o;
if (r.kind == NodeRef::Kind::Entity) o = sampledOriginForEntity(ents[r.index], clip, localFrame);
else o = sampledOriginForTool(tools[r.index], clip, localFrame);
if (r.kind == NodeRef::Kind::Entity) o = ents[r.index].originWorld;
else o = tools[r.index].originWorld;
resolvedOrigin.insert(id, o);
return o;
}
@@ -275,20 +149,23 @@ ResolvedProjectFrame evaluateAtFrame(const core::Project& project, int frame, in
if (r.kind == NodeRef::Kind::Entity) {
const auto& e = ents[r.index];
parentId = e.parentId;
selfSampled = sampledOriginForEntity(e, clip, localFrame);
selfSampled = e.parentId.isEmpty() ? e.originWorld : e.parentOffsetWorld;
if (animSample.entityPosition.contains(e.id)) {
selfSampled = animSample.entityPosition.value(e.id);
}
} else {
const auto& t = tools[r.index];
parentId = t.parentId;
selfSampled = sampledOriginForTool(t, clip, localFrame);
selfSampled = t.parentId.isEmpty() ? t.originWorld : t.parentOffsetWorld;
if (animSample.toolPosition.contains(t.id)) {
selfSampled = animSample.toolPosition.value(t.id);
}
}
QPointF outO = selfSampled;
if (!parentId.isEmpty() && index.contains(parentId)) {
const QPointF po = resolve(parentId);
const QPointF rel = (r.kind == NodeRef::Kind::Entity)
? sampledRelativeForEntity(ents[r.index], clip, localFrame)
: sampledRelativeForTool(tools[r.index], clip, localFrame);
outO = po + rel;
outO = po + selfSampled;
}
resolving.insert(id, false);
@@ -308,50 +185,69 @@ ResolvedProjectFrame evaluateAtFrame(const core::Project& project, int frame, in
for (int i = 0; i < ents.size(); ++i) {
core::Project::Entity e = ents[i];
const QPointF base = e.originWorld;
const QPointF ro = (!e.id.isEmpty()) ? resolve(e.id) : sampledOriginForEntity(e, clip, localFrame);
const QPointF ro = (!e.id.isEmpty()) ? resolve(e.id) : e.originWorld;
const QPointF delta = ro - base;
e.originWorld = ro;
e.imageTopLeftWorld += delta;
// Clip channels: userScale / imagePath（迁移后仍能逐帧显示）
if (clip && clip->entityUserScaleKeys.contains(e.id)) {
const auto& keys = clip->entityUserScaleKeys.value(e.id);
e.userScale = core::sampleUserScale(keys, localFrame, e.userScale, core::KeyInterpolation::Linear);
if (animSample.entityUserScale.contains(e.id)) {
e.userScale = animSample.entityUserScale.value(e.id);
}
if (clip && clip->entityImageFrames.contains(e.id)) {
const auto& frames = clip->entityImageFrames.value(e.id);
e.imagePath = core::sampleImagePath(frames, localFrame, e.imagePath);
if (animSample.entityDepthScale01.contains(e.id)) {
const double v01 = std::clamp(animSample.entityDepthScale01.value(e.id), 0.0, 1.0);
e.depth = int(std::lround(v01 * 255.0));
}
e.runtimeImagePng.clear();
if (animSample.entitySpritePng.contains(e.id)) {
const QByteArray png = animSample.entitySpritePng.value(e.id);
if (!png.isEmpty()) {
e.runtimeImagePng = png;
}
}
if (e.runtimeImagePng.isEmpty() && !e.defaultImagePng.isEmpty()) {
e.runtimeImagePng = e.defaultImagePng;
}
QVector<core::Project::ToolKeyframeBool> visKeys = e.visibilityKeys;
if (clip && clip->entityVisibilityKeys.contains(e.id)) {
visKeys = clip->entityVisibilityKeys.value(e.id);
if (animSample.entityPriority.contains(e.id)) {
const double p = animSample.entityPriority.value(e.id);
e.priority = std::clamp(int(std::lround(p)), -1000000, 1000000);
}
const double op = opacityWithDefault(visKeys, e.visible);
out.entities.push_back(ResolvedEntity{e, op});
const double animOp = animSample.entityVisibility.contains(e.id)
? (animSample.entityVisibility.value(e.id) ? 1.0 : 0.0)
: (e.visible ? 1.0 : 0.0);
out.entities.push_back(ResolvedEntity{e, animOp});
}
// Tools：resolved origin + opacity（可见性轨道）
for (int i = 0; i < tools.size(); ++i) {
core::Project::Tool t = tools[i];
const QPointF base = t.originWorld;
const QPointF ro = (!t.id.isEmpty()) ? resolve(t.id) : sampledOriginForTool(t, clip, localFrame);
const QPointF ro = (!t.id.isEmpty()) ? resolve(t.id) : t.originWorld;
const QPointF delta = ro - base;
t.originWorld = ro;
// parentOffsetWorld 已包含相对关系，不在这里改
QVector<core::Project::ToolKeyframeBool> visKeys = t.visibilityKeys;
if (clip && clip->toolVisibilityKeys.contains(t.id)) {
visKeys = clip->toolVisibilityKeys.value(t.id);
}
const double op = opacityWithDefault(visKeys, t.visible);
(void)delta;
out.tools.push_back(ResolvedTool{t, op});
if (animSample.toolPriority.contains(t.id)) {
const double p = animSample.toolPriority.value(t.id);
t.priority = std::clamp(int(std::lround(p)), -1000000, 1000000);
}
const double animOp = animSample.toolVisibility.contains(t.id)
? (animSample.toolVisibility.value(t.id) ? 1.0 : 0.0)
: (t.visible ? 1.0 : 0.0);
out.tools.push_back(ResolvedTool{t, animOp});
}
for (const auto& c : cams) {
core::Project::Camera cam = c;
cam.centerWorld = sampledCenterForCamera(c, clip, localFrame);
cam.viewScale = sampledViewScaleForCamera(c, clip, localFrame);
cam.centerWorld = c.centerWorld;
cam.viewScale = c.viewScale;
if (animSample.cameraPosition.contains(c.id)) {
cam.centerWorld = animSample.cameraPosition.value(c.id);
}
if (animSample.cameraScale.contains(c.id)) {
cam.viewScale = animSample.cameraScale.value(c.id);
}
out.cameras.push_back(ResolvedCamera{std::move(cam)});
}
client/core/eval/ProjectEvaluator.h
+3 -2
View File
@@ -29,8 +29,9 @@ struct ResolvedProjectFrame {
QVector<ResolvedCamera> cameras;
};
/// 逐帧求值：处理父子跟随与工具可见性淡入淡出。
ResolvedProjectFrame evaluateAtFrame(const core::Project& project, int frame, int fadeFrames = 10);
/// 逐帧求值：处理父子跟随与工具可见性淡入淡出。animationId 为空时使用 activeAnimationId（含既有回退）。
ResolvedProjectFrame evaluateAtFrame(const core::Project& project, int frame, int fadeFrames = 10,
const QString& animationId = QString());
} // namespace core::eval
client/core/image/ImageDecodeConfig.h
+60
View File
@@ -0,0 +1,60 @@
#pragma once
#include <QtGlobal>
#include <QImageReader>
#include <QRect>
#include <QSize>
#include <algorithm>
#include <cmath>
namespace core {
namespace image_decode {
/// 提高 Qt6 解码像素上限，避免大图被 reader 直接拒绝（单位 MB）
inline void prepareLargeImageReader() {
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
QImageReader::setAllocationLimit(4096);
#endif
}
/// 裁剪对话框等「仅预览」场景：像素上限（libvips 缩略与 Qt 回退共用）
[[maybe_unused]] constexpr qint64 kPreviewMaxPixels = 16LL * 1000 * 1000;
/// 编辑器 / 帧图替换：缩略像素上限（libvips 与 Qt 回退共用）
[[maybe_unused]] constexpr qint64 kWorkspaceMaxPixels = 48LL * 1000 * 1000;
/// 在 read() 前调用：若像素数超过 maxPixels，则 setScaledSize 按比例缩小（不解码全图）
inline void downscaleReaderIfExceeds(QImageReader& reader, qint64 maxPixels) {
const QSize sz = reader.size();
if (!sz.isValid() || sz.width() <= 0 || sz.height() <= 0) {
return;
}
const qint64 pixels = qint64(sz.width()) * qint64(sz.height());
if (pixels <= maxPixels) {
return;
}
const double s = std::sqrt(double(maxPixels) / double(pixels));
const int nw = std::max(1, int(std::lround(sz.width() * s)));
const int nh = std::max(1, int(std::lround(sz.height() * s)));
reader.setScaledSize(QSize(nw, nh));
}
/// 将 rect 从 fromSize 坐标系线性映射到 toSize（例如预览图上的选区 → 原图逻辑像素）
inline QRect mapRectBetweenSizes(const QRect& rect, const QSize& fromSize, const QSize& toSize) {
if (!rect.isValid() || fromSize.width() <= 0 || fromSize.height() <= 0 || toSize.width() <= 0 ||
toSize.height() <= 0) {
return {};
}
const qreal sx = qreal(toSize.width()) / qreal(fromSize.width());
const qreal sy = qreal(toSize.height()) / qreal(fromSize.height());
const int x0 = int(std::floor(qreal(rect.left()) * sx));
const int y0 = int(std::floor(qreal(rect.top()) * sy));
const int x1 = int(std::ceil(qreal(rect.right() + 1) * sx));
const int y1 = int(std::ceil(qreal(rect.bottom() + 1) * sy));
QRect out(x0, y0, x1 - x0, y1 - y0);
return out.normalized().intersected(QRect(0, 0, toSize.width(), toSize.height()));
}
} // namespace image_decode
} // namespace core
client/core/image/ImageFileLoader.cpp
+99
View File
@@ -0,0 +1,99 @@
#include "image/ImageFileLoader.h"
#include "image/ImageDecodeConfig.h"
#include "large_image/VipsBackend.h"
#include <QImageReader>
namespace core {
namespace image_file {
bool probeImagePixelSize(const QString& absolutePath, QSize* outSize) {
if (!outSize || absolutePath.isEmpty()) {
return false;
}
if (VipsBackend::isAvailable() && VipsBackend::probeSize(absolutePath, outSize)) {
return outSize->isValid() && outSize->width() > 0 && outSize->height() > 0;
}
core::image_decode::prepareLargeImageReader();
QImageReader reader(absolutePath);
reader.setAutoTransform(true);
*outSize = reader.size();
return outSize->isValid() && outSize->width() > 0 && outSize->height() > 0;
}
QImage loadImageLimited(const QString& absolutePath, qint64 maxPixelBudget) {
if (absolutePath.isEmpty()) {
return {};
}
QImage viaVips;
if (VipsBackend::isAvailable() &&
VipsBackend::loadThumbnailQImage(absolutePath, maxPixelBudget, &viaVips) && !viaVips.isNull()) {
return viaVips;
}
core::image_decode::prepareLargeImageReader();
QImageReader reader(absolutePath);
reader.setAutoTransform(true);
core::image_decode::downscaleReaderIfExceeds(reader, maxPixelBudget);
return reader.read();
}
bool loadRegionToQImage(const QString& absolutePath, const QRect& rectLogical, int maxOutputWidth, int maxOutputHeight,
QImage* out) {
if (!out || absolutePath.isEmpty() || maxOutputWidth < 32 || maxOutputHeight < 32) {
return false;
}
out->detach();
*out = QImage();
if (VipsBackend::isAvailable() &&
VipsBackend::loadRegionToQImage(absolutePath, rectLogical, maxOutputWidth, maxOutputHeight, out) &&
!out->isNull()) {
return true;
}
QSize logical;
if (!probeImagePixelSize(absolutePath, &logical)) {
return false;
}
const QRect r = rectLogical.intersected(QRect(0, 0, logical.width(), logical.height()));
if (r.isEmpty()) {
return false;
}
QImage full = loadImageLimited(absolutePath, core::image_decode::kWorkspaceMaxPixels);
if (full.isNull()) {
return false;
}
const QRect r2 = core::image_decode::mapRectBetweenSizes(r, logical, full.size());
QImage piece = full.copy(r2);
if (piece.isNull()) {
return false;
}
// 与 vips 路径保持一致：输出永不超过 maxOutput*，避免后续绘制阶段二次缩放导致明显“发糊”。
if (piece.width() > maxOutputWidth || piece.height() > maxOutputHeight) {
piece = piece.scaled(QSize(maxOutputWidth, maxOutputHeight), Qt::KeepAspectRatio, Qt::SmoothTransformation);
}
*out = piece;
return !out->isNull();
}
bool loadRegionToQImageExact(const QString& absolutePath, const QRect& rectLogical, QImage* out) {
if (!out || absolutePath.isEmpty()) {
return false;
}
out->detach();
*out = QImage();
QSize logical;
if (!probeImagePixelSize(absolutePath, &logical)) {
return false;
}
const QRect r = rectLogical.intersected(QRect(0, 0, logical.width(), logical.height()));
if (r.isEmpty()) {
return false;
}
// 1:1 输出：maxOutput 设为 region 本身大小，避免 vips/Qt 管线自动缩放导致坐标不一致。
const int w = std::max(1, r.width());
const int h = std::max(1, r.height());
return loadRegionToQImage(absolutePath, r, w, h, out);
}
} // namespace image_file
} // namespace core
client/core/image/ImageFileLoader.h
+29
View File
@@ -0,0 +1,29 @@
#pragma once
#include <QImage>
#include <QRect>
#include <QString>
#include <QSize>
#include <QtGlobal>
namespace core {
namespace image_file {
/// 仅读元数据（宽高），不解码像素；优先 libvips，否则 Qt QImageReader::size。
[[nodiscard]] bool probeImagePixelSize(const QString& absolutePath, QSize* outSize);
/// 统一大图解码管线：libvips（可用）按像素预算缩小后再解码为 QImage，否则 Qt。
[[nodiscard]] QImage loadImageLimited(const QString& absolutePath, qint64 maxPixelBudget);
/// 仅解码源图中矩形区域（逻辑像素坐标）；超过 maxOutput* 则缩放该区域。
/// libvips 可用时走随机访问裁剪；否则整图降采样回退后再拷贝矩形。
[[nodiscard]] bool loadRegionToQImage(const QString& absolutePath, const QRect& rectLogical, int maxOutputWidth,
int maxOutputHeight, QImage* out);
/// 仅解码源图中矩形区域（逻辑像素坐标），并保证输出为 1:1 像素（不缩放）。
/// 用于抠图/像素对齐等需要严格坐标一致的场景。
[[nodiscard]] bool loadRegionToQImageExact(const QString& absolutePath, const QRect& rectLogical, QImage* out);
} // namespace image_file
} // namespace core
client/core/large_image/VipsBackend.cpp
+271
View File
@@ -0,0 +1,271 @@
// 必须在任何 Qt 头（会定义宏 signals）之前包含 vips/glib
#ifdef LT_HAVE_VIPS
# include <vips/vips.h>
#endif
#include "large_image/VipsBackend.h"
#include <QByteArray>
#include <QFile>
#include <QFileInfo>
#include <algorithm>
#include <cmath>
#include <cstdlib>
namespace core {
#ifdef LT_HAVE_VIPS
namespace {
bool gReady = false;
QByteArray encodedPath(const QString& path) {
return QFile::encodeName(path);
}
bool saveVipsImageToPngFile(VipsImage* img, const QString& destPath) {
if (!img) {
return false;
}
const QByteArray dest = encodedPath(destPath);
if (vips_pngsave(img, dest.constData(), "compression", 3, nullptr) != 0) {
return false;
}
return true;
}
} // namespace
bool VipsBackend::init(const char* argv0) {
if (gReady) {
return true;
}
if (vips_init(argv0) != 0) {
return false;
}
gReady = true;
return true;
}
void VipsBackend::shutdown() {
if (!gReady) {
return;
}
vips_shutdown();
gReady = false;
}
bool VipsBackend::isAvailable() {
return gReady;
}
bool VipsBackend::probeSize(const QString& path, QSize* out) {
if (!gReady || !out) {
return false;
}
const QByteArray enc = encodedPath(path);
if (enc.isEmpty()) {
return false;
}
VipsImage* in = vips_image_new_from_file(enc.constData(), "access", VIPS_ACCESS_SEQUENTIAL, nullptr);
if (!in) {
return false;
}
const int w = vips_image_get_width(in);
const int h = vips_image_get_height(in);
g_object_unref(in);
if (w <= 0 || h <= 0) {
return false;
}
*out = QSize(w, h);
return true;
}
bool VipsBackend::loadThumbnailQImage(const QString& path, qint64 maxPixels, QImage* out) {
if (!gReady || !out || maxPixels < 1024) {
return false;
}
const QByteArray enc = encodedPath(path);
if (enc.isEmpty()) {
return false;
}
QSize sz;
if (!probeSize(path, &sz)) {
return false;
}
const qint64 pixels = qint64(sz.width()) * qint64(sz.height());
if (pixels <= 0) {
return false;
}
VipsImage* thumb = nullptr;
if (pixels <= maxPixels) {
thumb = vips_image_new_from_file(enc.constData(), "access", VIPS_ACCESS_SEQUENTIAL, nullptr);
if (!thumb) {
return false;
}
} else {
const int targetW =
std::max(1, int(std::floor(std::sqrt(double(maxPixels) * double(sz.width()) / double(sz.height())))));
if (vips_thumbnail(enc.constData(), &thumb, targetW, nullptr) != 0) {
return false;
}
}
void* buf = nullptr;
size_t len = 0;
if (vips_pngsave_buffer(thumb, &buf, &len, "compression", 3, nullptr) != 0) {
g_object_unref(thumb);
return false;
}
g_object_unref(thumb);
const bool ok = out->loadFromData(static_cast<const uchar*>(buf), static_cast<int>(len), "PNG");
g_free(buf);
return ok && !out->isNull();
}
bool VipsBackend::loadRegionToQImage(const QString& sourcePath, const QRect& rectInSource, int maxOutputWidth,
int maxOutputHeight, QImage* out) {
if (!gReady || !out || maxOutputWidth < 32 || maxOutputHeight < 32) {
return false;
}
out->detach();
*out = QImage();
const QByteArray src = encodedPath(sourcePath);
if (src.isEmpty()) {
return false;
}
VipsImage* in = vips_image_new_from_file(src.constData(), "access", VIPS_ACCESS_RANDOM, nullptr);
if (!in) {
return false;
}
const int iw = vips_image_get_width(in);
const int ih = vips_image_get_height(in);
const QRect bounds(0, 0, iw, ih);
QRect r = rectInSource.normalized().intersected(bounds);
if (r.width() <= 0 || r.height() <= 0) {
g_object_unref(in);
return false;
}
VipsImage* cropped = nullptr;
if (vips_crop(in, &cropped, r.left(), r.top(), r.width(), r.height(), nullptr) != 0) {
g_object_unref(in);
return false;
}
g_object_unref(in);
const int cw = r.width();
const int ch = r.height();
VipsImage* toEncode = cropped;
// 视口解码：输出尺寸不应超过 maxOutput*，否则后续绘制阶段再缩小会引入明显的线性滤波“发糊”。
// 这里始终把区域降采样到不超过 maxOutput*（保持宽高比），让 vips 在解码阶段完成高质量缩放。
double scale = 1.0;
if (cw > maxOutputWidth || ch > maxOutputHeight) {
const double sx = static_cast<double>(maxOutputWidth) / static_cast<double>(cw);
const double sy = static_cast<double>(maxOutputHeight) / static_cast<double>(ch);
scale = std::min({sx, sy, 1.0});
}
if (scale < 0.9999) {
VipsImage* resized = nullptr;
if (vips_resize(cropped, &resized, scale, "kernel", VIPS_KERNEL_LANCZOS3, nullptr) != 0) {
g_object_unref(cropped);
return false;
}
g_object_unref(cropped);
toEncode = resized;
}
void* buf = nullptr;
size_t len = 0;
if (vips_pngsave_buffer(toEncode, &buf, &len, "compression", 3, nullptr) != 0) {
g_object_unref(toEncode);
return false;
}
g_object_unref(toEncode);
const bool ok = out->loadFromData(static_cast<const uchar*>(buf), static_cast<int>(len), "PNG");
g_free(buf);
return ok && !out->isNull();
}
bool VipsBackend::saveRectToPng(const QString& sourcePath, const QRect& rectInSource, const QString& destPngPath) {
if (!gReady) {
return false;
}
const QByteArray src = encodedPath(sourcePath);
if (src.isEmpty()) {
return false;
}
VipsImage* in = vips_image_new_from_file(src.constData(), "access", VIPS_ACCESS_RANDOM, nullptr);
if (!in) {
return false;
}
const int iw = vips_image_get_width(in);
const int ih = vips_image_get_height(in);
const QRect bounds(0, 0, iw, ih);
QRect r = rectInSource.normalized().intersected(bounds);
if (r.width() <= 0 || r.height() <= 0) {
g_object_unref(in);
return false;
}
VipsImage* toSave = in;
VipsImage* cropped = nullptr;
if (r != bounds) {
if (vips_crop(in, &cropped, r.left(), r.top(), r.width(), r.height(), nullptr) != 0) {
g_object_unref(in);
return false;
}
toSave = cropped;
}
const bool ok = saveVipsImageToPngFile(toSave, destPngPath);
if (cropped) {
g_object_unref(cropped);
}
g_object_unref(in);
return ok;
}
#else // !LT_HAVE_VIPS
bool VipsBackend::init(const char*) {
return false;
}
void VipsBackend::shutdown() {}
bool VipsBackend::isAvailable() {
return false;
}
bool VipsBackend::probeSize(const QString&, QSize*) {
return false;
}
bool VipsBackend::loadThumbnailQImage(const QString&, qint64, QImage*) {
return false;
}
bool VipsBackend::saveRectToPng(const QString&, const QRect&, const QString&) {
return false;
}
bool VipsBackend::loadRegionToQImage(const QString&, const QRect&, int, int, QImage*) {
return false;
}
#endif // LT_HAVE_VIPS
} // namespace core
client/core/large_image/VipsBackend.h
+39
View File
@@ -0,0 +1,39 @@
#pragma once
#include <QtGlobal>
#include <QImage>
#include <QRect>
#include <QString>
namespace core {
/// 基于 libvips 的大图 I/O：随机访问裁剪、流式写 PNG、缩略预览，避免整图进内存。
/// 未编译 libvips 时 API 返回 false，由调用方回退到 Qt。
class VipsBackend {
public:
/// 须在 QApplication 创建后调用一次，argv0 建议为 argv[0]。
static bool init(const char* argv0);
static void shutdown();
static bool isAvailable();
/// 打开文件读取宽高（轻量，不解码全图）
static bool probeSize(const QString& path, QSize* out);
/// 生成预览图（总像素约不超过 maxPixels），用于裁剪对话框 / 画布
static bool loadThumbnailQImage(const QString& path, qint64 maxPixels, QImage* out);
/// 将原图中矩形区域（像素坐标，含边界）无损写入 PNG；区域为整图时直接流式转存。
/// 适合 GB 级 PNG，不构建整幅 QImage。
static bool saveRectToPng(const QString& sourcePath, const QRect& rectInSource, const QString& destPngPath);
/// 裁剪原图矩形区域；若超过 maxOutput* 则按比例缩小（不降采样整图，只处理该区域）。
static bool loadRegionToQImage(const QString& sourcePath, const QRect& rectInSource, int maxOutputWidth,
int maxOutputHeight, QImage* out);
private:
VipsBackend() = default;
};
} // namespace core
client/core/library/EntityJson.cpp
+18 -2
View File
@@ -2,7 +2,9 @@
#include <functional>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonValue>
#include <QRect>
namespace core::library {
@@ -70,6 +72,15 @@ QJsonObject entityToJson(const core::Project::Entity& e) {
o.insert(QStringLiteral("blackholeId"), e.blackholeId);
o.insert(QStringLiteral("blackholeVisible"), e.blackholeVisible);
o.insert(QStringLiteral("blackholeResolvedBy"), e.blackholeResolvedBy);
o.insert(QStringLiteral("blackholeOverlayPath"), e.blackholeOverlayPath);
{
QJsonObject r;
r.insert(QStringLiteral("x"), e.blackholeOverlayRect.x());
r.insert(QStringLiteral("y"), e.blackholeOverlayRect.y());
r.insert(QStringLiteral("w"), e.blackholeOverlayRect.width());
r.insert(QStringLiteral("h"), e.blackholeOverlayRect.height());
o.insert(QStringLiteral("blackholeOverlayRect"), r);
}
o.insert(QStringLiteral("originWorld"), pointToJson(e.originWorld));
o.insert(QStringLiteral("depth"), e.depth);
o.insert(QStringLiteral("imagePath"), e.imagePath);
@@ -81,7 +92,6 @@ QJsonObject entityToJson(const core::Project::Entity& e) {
o.insert(QStringLiteral("parentOffsetWorld"), pointToJson(e.parentOffsetWorld));
o.insert(QStringLiteral("entityPayloadPath"), e.entityPayloadPath);
o.insert(QStringLiteral("legacyAnimSidecarPath"), e.legacyAnimSidecarPath);
o.insert(QStringLiteral("locationKeys"),
vecToJson<core::Project::Entity::KeyframeVec2>(
@@ -161,6 +171,13 @@ bool entityFromJson(const QJsonObject& o, core::Project::Entity& out) {
}
e.blackholeVisible = o.value(QStringLiteral("blackholeVisible")).toBool(true);
e.blackholeResolvedBy = o.value(QStringLiteral("blackholeResolvedBy")).toString();
e.blackholeOverlayPath = o.value(QStringLiteral("blackholeOverlayPath")).toString();
{
const QJsonObject r = o.value(QStringLiteral("blackholeOverlayRect")).toObject();
e.blackholeOverlayRect =
QRect(r.value(QStringLiteral("x")).toInt(0), r.value(QStringLiteral("y")).toInt(0),
r.value(QStringLiteral("w")).toInt(0), r.value(QStringLiteral("h")).toInt(0));
}
{
QPointF p;
if (!pointFromJson(o.value(QStringLiteral("originWorld")), p)) {
@@ -189,7 +206,6 @@ bool entityFromJson(const QJsonObject& o, core::Project::Entity& out) {
e.parentOffsetWorld = p;
}
e.entityPayloadPath = o.value(QStringLiteral("entityPayloadPath")).toString();
e.legacyAnimSidecarPath = o.value(QStringLiteral("legacyAnimSidecarPath")).toString();
auto parseKeyframesVec2 = [&](const QString& key, QVector<core::Project::Entity::KeyframeVec2>& dst) -> bool {
dst.clear();
client/core/net/ModelServerClient.cpp
+62
View File
@@ -10,6 +10,8 @@
#include <QTimer>
#include <QUrl>
#include <algorithm>
namespace core {
ModelServerClient::ModelServerClient(QObject* parent)
@@ -90,6 +92,7 @@ QNetworkReply* ModelServerClient::segmentSamPromptAsync(
QNetworkReply* ModelServerClient::inpaintAsync(
const QByteArray& cropRgbPngBytes,
const QByteArray& maskPngBytes,
const QString& modelName,
const QString& prompt,
const QString& negativePrompt,
double strength,
@@ -119,6 +122,9 @@ QNetworkReply* ModelServerClient::inpaintAsync(
QJsonObject payload;
payload.insert(QStringLiteral("image_b64"), QString::fromLatin1(cropRgbPngBytes.toBase64()));
payload.insert(QStringLiteral("mask_b64"), QString::fromLatin1(maskPngBytes.toBase64()));
if (!modelName.trimmed().isEmpty()) {
payload.insert(QStringLiteral("model_name"), modelName.trimmed());
}
payload.insert(QStringLiteral("prompt"), prompt);
payload.insert(QStringLiteral("negative_prompt"), negativePrompt);
payload.insert(QStringLiteral("strength"), strength);
@@ -128,6 +134,62 @@ QNetworkReply* ModelServerClient::inpaintAsync(
return m_nam->post(req, body);
}
QNetworkReply* ModelServerClient::animateCharacterSequenceAsync(
const QByteArray& characterPngBytes,
const QString& prompt,
const QString& negativePrompt,
const QString& backgroundColor,
int backgroundTolerance,
int frameCount,
int numInferenceSteps,
double guidanceScale,
int maxSide,
int seed,
QString* outImmediateError
) {
if (outImmediateError) {
outImmediateError->clear();
}
if (!m_baseUrl.isValid() || m_baseUrl.isEmpty()) {
if (outImmediateError) *outImmediateError = QStringLiteral("后端地址无效。");
return nullptr;
}
if (characterPngBytes.isEmpty()) {
if (outImmediateError) *outImmediateError = QStringLiteral("角色 PNG 为空。");
return nullptr;
}
if (prompt.trimmed().isEmpty()) {
if (outImmediateError) *outImmediateError = QStringLiteral("动画提示词不能为空。");
return nullptr;
}
if (frameCount <= 0) {
if (outImmediateError) *outImmediateError = QStringLiteral("帧数必须大于 0。");
return nullptr;
}
const QUrl url = m_baseUrl.resolved(QUrl(QStringLiteral("/animate/character_sequence")));
QNetworkRequest req(url);
req.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/json"));
QJsonObject payload;
payload.insert(QStringLiteral("image_b64"), QString::fromLatin1(characterPngBytes.toBase64()));
payload.insert(QStringLiteral("model_name"), QStringLiteral("animatediff"));
payload.insert(QStringLiteral("prompt"), prompt.trimmed());
payload.insert(QStringLiteral("negative_prompt"), negativePrompt);
payload.insert(QStringLiteral("background_color"), backgroundColor.trimmed().isEmpty()
? QStringLiteral("#00FF00")
: backgroundColor.trimmed());
payload.insert(QStringLiteral("background_tolerance"), std::clamp(backgroundTolerance, 0, 255));
payload.insert(QStringLiteral("video_length"), frameCount);
payload.insert(QStringLiteral("num_inference_steps"), std::max(1, numInferenceSteps));
payload.insert(QStringLiteral("guidance_scale"), guidanceScale);
payload.insert(QStringLiteral("max_side"), std::clamp(maxSide, 128, 2048));
payload.insert(QStringLiteral("seed"), seed);
const QByteArray body = QJsonDocument(payload).toJson(QJsonDocument::Compact);
return m_nam->post(req, body);
}
bool ModelServerClient::computeDepthPng8(
const QByteArray& imageBytes,
QByteArray& outPngBytes,
client/core/net/ModelServerClient.h
+15
View File
@@ -41,12 +41,27 @@ public:
QNetworkReply* inpaintAsync(
const QByteArray& cropRgbPngBytes,
const QByteArray& maskPngBytes,
const QString& modelName,
const QString& prompt,
const QString& negativePrompt,
double strength,
int maxSide,
QString* outImmediateError = nullptr);
// POST /animate/character_sequence，JSON 响应由调用方解析（success / frames[] / fps / error）。
QNetworkReply* animateCharacterSequenceAsync(
const QByteArray& characterPngBytes,
const QString& prompt,
const QString& negativePrompt,
const QString& backgroundColor,
int backgroundTolerance,
int frameCount,
int numInferenceSteps,
double guidanceScale,
int maxSide,
int seed,
QString* outImmediateError = nullptr);
private:
QNetworkAccessManager* m_nam = nullptr;
QUrl m_baseUrl;
client/core/persistence/AnimationBinary.cpp
+204
View File
@@ -0,0 +1,204 @@
#include "persistence/AnimationBinary.h"
#include "persistence/PersistentBinaryObject.h"
#include <QDataStream>
#include <QFile>
#include <algorithm>
namespace core {
namespace {
qint32 toInt(Project::AnimationTargetKind v) {
return static_cast<qint32>(v);
}
qint32 toInt(Project::AnimationProperty v) {
return static_cast<qint32>(v);
}
qint32 toInt(Project::AnimationValueType v) {
return static_cast<qint32>(v);
}
qint32 toInt(Project::AnimationInterpolation v) {
return static_cast<qint32>(v);
}
Project::AnimationTargetKind targetKindFromInt(qint32 v) {
if (v == toInt(Project::AnimationTargetKind::Tool)) return Project::AnimationTargetKind::Tool;
if (v == toInt(Project::AnimationTargetKind::Camera)) return Project::AnimationTargetKind::Camera;
return Project::AnimationTargetKind::Entity;
}
Project::AnimationProperty propertyFromInt(qint32 v) {
switch (v) {
case 1: return Project::AnimationProperty::UserScale;
case 2: return Project::AnimationProperty::Sprite;
case 3: return Project::AnimationProperty::Visibility;
case 4: return Project::AnimationProperty::DepthScale;
case 5: return Project::AnimationProperty::CameraScale;
default: return Project::AnimationProperty::Position;
}
}
Project::AnimationValueType valueTypeFromInt(qint32 v) {
switch (v) {
case 1: return Project::AnimationValueType::Double;
case 2: return Project::AnimationValueType::Bool;
case 3: return Project::AnimationValueType::ImagePath;
case 4: return Project::AnimationValueType::PngBytes;
default: return Project::AnimationValueType::Vec2;
}
}
Project::AnimationInterpolation interpolationFromInt(qint32 v) {
return v == 0 ? Project::AnimationInterpolation::Hold : Project::AnimationInterpolation::Linear;
}
void sortAndDedupe(QVector<Project::AnimationKey>& keys) {
std::sort(keys.begin(), keys.end(), [](const auto& a, const auto& b) {
return a.frame < b.frame;
});
QVector<Project::AnimationKey> out;
out.reserve(keys.size());
for (const auto& k : keys) {
if (!out.isEmpty() && out.last().frame == k.frame) {
out.last() = k;
} else {
out.push_back(k);
}
}
keys = std::move(out);
}
class AnimationRecord final : public PersistentBinaryObject {
public:
explicit AnimationRecord(const Project::Animation& animation) : m_src(&animation), m_dst(nullptr) {}
explicit AnimationRecord(Project::Animation& animation) : m_src(nullptr), m_dst(&animation) {}
quint32 recordMagic() const override { return AnimationBinary::kMagicAnimation; }
quint32 recordFormatVersion() const override { return AnimationBinary::kAnimationVersion; }
void writeBody(QDataStream& ds) const override {
const Project::Animation& a = *m_src;
ds << a.id << a.name << a.payloadPath;
ds << qint32(a.fps) << qint32(a.lengthFrames) << bool(a.loop);
ds << qint32(a.tracks.size());
for (const auto& t : a.tracks) {
ds << t.id << toInt(t.targetKind) << t.targetId << toInt(t.property)
<< toInt(t.valueType) << toInt(t.interpolation);
ds << qint32(t.keys.size());
for (const auto& k : t.keys) {
ds << qint32(k.frame);
switch (t.valueType) {
case Project::AnimationValueType::Vec2:
ds << double(k.vec2Value.x()) << double(k.vec2Value.y());
break;
case Project::AnimationValueType::Double:
ds << double(k.numberValue);
break;
case Project::AnimationValueType::Bool:
ds << bool(k.boolValue);
break;
case Project::AnimationValueType::ImagePath:
ds << k.stringValue;
break;
case Project::AnimationValueType::PngBytes:
ds << k.bytesValue;
break;
}
}
}
}
bool readBody(QDataStream& ds) override {
Project::Animation a;
qint32 fps = 30;
qint32 length = Project::kClipFixedFrames;
bool loop = true;
ds >> a.id >> a.name >> a.payloadPath;
ds >> fps >> length >> loop;
if (ds.status() != QDataStream::Ok || a.id.isEmpty()) return false;
a.fps = std::max(1, int(fps));
a.lengthFrames = std::max(1, int(length));
a.loop = loop;
qint32 nTracks = 0;
ds >> nTracks;
if (ds.status() != QDataStream::Ok || nTracks < 0 || nTracks > 100000) return false;
a.tracks.reserve(nTracks);
for (qint32 i = 0; i < nTracks; ++i) {
Project::AnimationTrack t;
qint32 kind = 0;
qint32 prop = 0;
qint32 valueType = 0;
qint32 interpolation = 1;
ds >> t.id >> kind >> t.targetId >> prop >> valueType >> interpolation;
if (ds.status() != QDataStream::Ok || t.targetId.isEmpty()) return false;
t.targetKind = targetKindFromInt(kind);
t.property = propertyFromInt(prop);
t.valueType = valueTypeFromInt(valueType);
t.interpolation = interpolationFromInt(interpolation);
qint32 nKeys = 0;
ds >> nKeys;
if (ds.status() != QDataStream::Ok || nKeys < 0 || nKeys > 1000000) return false;
t.keys.reserve(nKeys);
for (qint32 kidx = 0; kidx < nKeys; ++kidx) {
Project::AnimationKey k;
qint32 frame = 0;
ds >> frame;
k.frame = int(frame);
switch (t.valueType) {
case Project::AnimationValueType::Vec2: {
double x = 0.0;
double y = 0.0;
ds >> x >> y;
k.vec2Value = QPointF(x, y);
break;
}
case Project::AnimationValueType::Double:
ds >> k.numberValue;
break;
case Project::AnimationValueType::Bool:
ds >> k.boolValue;
break;
case Project::AnimationValueType::ImagePath:
ds >> k.stringValue;
break;
case Project::AnimationValueType::PngBytes:
ds >> k.bytesValue;
break;
}
if (ds.status() != QDataStream::Ok) return false;
t.keys.push_back(k);
}
sortAndDedupe(t.keys);
a.tracks.push_back(t);
}
*m_dst = std::move(a);
return true;
}
private:
const Project::Animation* m_src;
Project::Animation* m_dst;
};
} // namespace
bool AnimationBinary::save(const QString& absolutePath, const Project::Animation& animation) {
if (absolutePath.isEmpty() || animation.id.isEmpty()) {
return false;
}
return AnimationRecord(animation).saveToFile(absolutePath);
}
bool AnimationBinary::load(const QString& absolutePath, Project::Animation& animation) {
return AnimationRecord(animation).loadFromFile(absolutePath);
}
} // namespace core
client/core/persistence/AnimationBinary.h
+18
View File
@@ -0,0 +1,18 @@
#pragma once
#include "domain/Project.h"
#include <QString>
namespace core {
class AnimationBinary {
public:
static constexpr quint32 kMagicAnimation = 0x4846414E; // 'HFAN'
static constexpr quint32 kAnimationVersion = 2;
static bool save(const QString& absolutePath, const Project::Animation& animation);
static bool load(const QString& absolutePath, Project::Animation& animation);
};
} // namespace core
client/core/persistence/AnimationBundleStore.cpp
+162
View File
@@ -0,0 +1,162 @@
#include "persistence/AnimationBundleStore.h"
#include "persistence/JsonFileAtomic.h"
#include <QDir>
#include <QFileInfo>
#include <QJsonArray>
#include <QJsonObject>
namespace core::persistence {
namespace {
QJsonObject keyToJson(const Project::AnimationKey& k, Project::AnimationValueType t) {
QJsonObject o;
o.insert("frame", k.frame);
switch (t) {
case Project::AnimationValueType::Vec2:
o.insert("x", k.vec2Value.x());
o.insert("y", k.vec2Value.y());
break;
case Project::AnimationValueType::Double:
o.insert("value", k.numberValue);
break;
case Project::AnimationValueType::Bool:
o.insert("value", k.boolValue);
break;
case Project::AnimationValueType::ImagePath:
o.insert("value", k.stringValue);
break;
case Project::AnimationValueType::PngBytes:
o.insert("value", QString::fromLatin1(k.bytesValue.toBase64()));
break;
}
return o;
}
bool keyFromJson(const QJsonObject& o, Project::AnimationValueType t, Project::AnimationKey& out) {
out = Project::AnimationKey{};
out.frame = o.value("frame").toInt(0);
switch (t) {
case Project::AnimationValueType::Vec2:
out.vec2Value = QPointF(o.value("x").toDouble(0.0), o.value("y").toDouble(0.0));
break;
case Project::AnimationValueType::Double:
out.numberValue = o.value("value").toDouble(0.0);
break;
case Project::AnimationValueType::Bool:
out.boolValue = o.value("value").toBool(true);
break;
case Project::AnimationValueType::ImagePath:
out.stringValue = o.value("value").toString();
break;
case Project::AnimationValueType::PngBytes: {
const QByteArray b64 = o.value("value").toString().toLatin1();
out.bytesValue = QByteArray::fromBase64(b64);
break;
}
}
return true;
}
} // namespace
QString AnimationBundleStore::bundleRelativeDir(const QString& animationId) {
if (animationId.isEmpty()) return {};
return QStringLiteral("assets/animations/%1").arg(animationId);
}
bool AnimationBundleStore::save(const QString& projectDirAbs, const Project::Animation& animation) {
if (projectDirAbs.isEmpty() || animation.id.isEmpty()) {
return false;
}
const QString relDir = bundleRelativeDir(animation.id);
if (relDir.isEmpty()) return false;
const QString absDir = QDir(projectDirAbs).filePath(relDir);
QDir().mkpath(absDir);
QJsonObject root;
root.insert("id", animation.id);
root.insert("name", animation.name);
root.insert("fps", animation.fps);
root.insert("lengthFrames", animation.lengthFrames);
root.insert("loop", animation.loop);
QJsonArray tracks;
for (const auto& t : animation.tracks) {
QJsonObject to;
to.insert("id", t.id);
to.insert("targetKind", int(t.targetKind));
to.insert("targetId", t.targetId);
to.insert("property", int(t.property));
to.insert("valueType", int(t.valueType));
to.insert("interpolation", int(t.interpolation));
QJsonArray keys;
for (const auto& k : t.keys) {
keys.append(keyToJson(k, t.valueType));
}
to.insert("keys", keys);
tracks.append(to);
}
root.insert("tracks", tracks);
return writeJsonAtomic(QDir(absDir).filePath(QStringLiteral("anim.json")), root, true);
}
bool AnimationBundleStore::load(const QString& projectDirAbs, Project::Animation& inOutAnimation) {
if (projectDirAbs.isEmpty() || inOutAnimation.id.isEmpty()) {
return false;
}
const QString relDir = inOutAnimation.payloadPath;
if (relDir.isEmpty()) return false;
const QString absDir = QDir(projectDirAbs).filePath(relDir);
if (!QFileInfo(absDir).exists()) return false;
QJsonObject root;
if (!readJsonObject(QDir(absDir).filePath(QStringLiteral("anim.json")), root)) {
return false;
}
const QString id = root.value("id").toString();
if (id.isEmpty() || id != inOutAnimation.id) {
return false;
}
Project::Animation a = inOutAnimation;
a.name = root.value("name").toString();
a.fps = std::max(1, root.value("fps").toInt(30));
a.lengthFrames = std::max(1, root.value("lengthFrames").toInt(Project::kClipFixedFrames));
a.loop = root.value("loop").toBool(true);
a.tracks.clear();
const QJsonValue tracksVal = root.value("tracks");
if (tracksVal.isArray()) {
for (const auto& it : tracksVal.toArray()) {
if (!it.isObject()) continue;
const QJsonObject to = it.toObject();
Project::AnimationTrack t;
t.id = to.value("id").toString();
t.targetKind = Project::AnimationTargetKind(to.value("targetKind").toInt(0));
t.targetId = to.value("targetId").toString();
t.property = Project::AnimationProperty(to.value("property").toInt(0));
t.valueType = Project::AnimationValueType(to.value("valueType").toInt(0));
t.interpolation = Project::AnimationInterpolation(to.value("interpolation").toInt(1));
const QJsonValue keysVal = to.value("keys");
if (keysVal.isArray()) {
for (const auto& kv : keysVal.toArray()) {
if (!kv.isObject()) continue;
Project::AnimationKey k;
keyFromJson(kv.toObject(), t.valueType, k);
t.keys.push_back(k);
}
}
if (!t.targetId.isEmpty()) {
a.tracks.push_back(t);
}
}
}
inOutAnimation = std::move(a);
return true;
}
} // namespace core::persistence
client/core/persistence/AnimationBundleStore.h
+20
View File
@@ -0,0 +1,20 @@
#pragma once
#include "domain/Project.h"
#include <QString>
namespace core::persistence {
/// 动画 payload 的目录 bundle（v7 起）：
/// assets/animations/<id>/
/// anim.json // 元数据 + 所有 track（后续可拆成按 track 分块）
struct AnimationBundleStore {
static QString bundleRelativeDir(const QString& animationId);
static bool save(const QString& projectDirAbs, const Project::Animation& animation);
static bool load(const QString& projectDirAbs, Project::Animation& inOutAnimation);
};
} // namespace core::persistence
client/core/persistence/AsyncProjectWriter.cpp
+139
View File
@@ -0,0 +1,139 @@
#include "persistence/AsyncProjectWriter.h"
#include "persistence/AnimationBundleStore.h"
#include "persistence/EntityBundleStore.h"
#include <QCoreApplication>
#include <QDir>
#include <QEventLoop>
#include <QTimer>
#include <QtConcurrent/QtConcurrent>
namespace core::persistence {
AsyncProjectWriter::AsyncProjectWriter(QObject* parent)
: QObject(parent) {
m_debounce = new QTimer(this);
m_debounce->setSingleShot(true);
m_debounce->setInterval(80);
connect(m_debounce, &QTimer::timeout, this, [this]() { scheduleDrain(); });
}
void AsyncProjectWriter::setProjectDir(const QString& projectDirAbs) {
m_projectDir = projectDirAbs;
}
void AsyncProjectWriter::requestWriteEntity(const Project::Entity& entity) {
if (m_projectDir.isEmpty() || entity.id.isEmpty()) {
return;
}
{
std::lock_guard lock(m_mutex);
m_pendingEntities.insert(entity.id, entity);
}
if (m_debounce) {
m_debounce->start();
}
}
void AsyncProjectWriter::requestWriteAnimation(const Project::Animation& animation) {
if (m_projectDir.isEmpty() || animation.id.isEmpty()) {
return;
}
{
std::lock_guard lock(m_mutex);
m_pendingAnimations.insert(animation.id, animation);
}
if (m_debounce) {
m_debounce->start();
}
}
void AsyncProjectWriter::scheduleDrain() {
const QString dir = m_projectDir;
if (dir.isEmpty()) {
return;
}
QHash<QString, Project::Entity> ents;
QHash<QString, Project::Animation> anims;
{
std::lock_guard lock(m_mutex);
ents = std::move(m_pendingEntities);
anims = std::move(m_pendingAnimations);
m_pendingEntities.clear();
m_pendingAnimations.clear();
}
if (ents.isEmpty() && anims.isEmpty()) {
return;
}
m_outstandingDrains.fetch_add(1, std::memory_order_acq_rel);
(void)QtConcurrent::run([this, dir, ents = std::move(ents), anims = std::move(anims)]() mutable {
bool anyFail = false;
for (auto it = ents.begin(); it != ents.end(); ++it) {
const Project::Entity& e = it.value();
if (!EntityBundleStore::save(dir, e)) {
anyFail = true;
QMetaObject::invokeMethod(this, [this, id = e.id]() { emit entityWriteFailed(id); },
Qt::QueuedConnection);
}
}
for (auto it = anims.begin(); it != anims.end(); ++it) {
const Project::Animation& a = it.value();
if (!AnimationBundleStore::save(dir, a)) {
anyFail = true;
QMetaObject::invokeMethod(this, [this, id = a.id]() { emit animationWriteFailed(id); },
Qt::QueuedConnection);
}
}
Q_UNUSED(anyFail);
m_outstandingDrains.fetch_sub(1, std::memory_order_acq_rel);
});
// drain 期间若又有新请求，再开一轮
{
std::lock_guard lock(m_mutex);
if (!m_pendingEntities.isEmpty() || !m_pendingAnimations.isEmpty()) {
if (m_debounce) {
m_debounce->start();
}
}
}
}
void AsyncProjectWriter::flushBlocking(int timeoutMs) {
if (m_projectDir.isEmpty()) {
return;
}
if (m_debounce) {
m_debounce->stop();
}
QMetaObject::invokeMethod(
this,
[this]() {
scheduleDrain();
},
Qt::QueuedConnection);
QTimer killer;
killer.setSingleShot(true);
killer.start(std::max(0, timeoutMs));
while (killer.isActive()) {
bool idle = false;
{
std::lock_guard lock(m_mutex);
idle =
m_pendingEntities.isEmpty() && m_pendingAnimations.isEmpty() &&
m_outstandingDrains.load(std::memory_order_acquire) == 0;
}
if (idle) {
break;
}
QCoreApplication::processEvents(QEventLoop::AllEvents, 20);
}
}
} // namespace core::persistence
client/core/persistence/AsyncProjectWriter.h
+51
View File
@@ -0,0 +1,51 @@
#pragma once
#include "domain/Project.h"
#include <QHash>
#include <QObject>
#include <QSet>
#include <QString>
#include <QTimer>
#include <atomic>
#include <mutex>
namespace core::persistence {
/// 后台写盘队列：合并/防抖，避免 UI 线程同步写文件。
/// 目前以“实体/动画为单位”合并；后续会细化到块级 dirty bits（meta/anim/intro/png...）。
class AsyncProjectWriter final : public QObject {
Q_OBJECT
public:
explicit AsyncProjectWriter(QObject* parent = nullptr);
void setProjectDir(const QString& projectDirAbs);
/// enqueue：线程安全由调用方保证在 UI 线程调用（本类内部用 singleShot 防抖到 writer 线程）。
void requestWriteEntity(const Project::Entity& entity);
void requestWriteAnimation(const Project::Animation& animation);
/// 阻塞等待：用于 close/退出时确保落盘完成。
void flushBlocking(int timeoutMs = 30000);
signals:
void entityWriteFailed(const QString& entityId);
void animationWriteFailed(const QString& animationId);
private:
void scheduleDrain();
QString m_projectDir;
QTimer* m_debounce = nullptr;
std::mutex m_mutex;
// 最新快照：同 id 多次更新只写最后一次
QHash<QString, Project::Entity> m_pendingEntities;
QHash<QString, Project::Animation> m_pendingAnimations;
std::atomic<int> m_outstandingDrains{0};
};
} // namespace core::persistence
client/core/persistence/EntityBundleStore.cpp
+362
View File
@@ -0,0 +1,362 @@
#include "persistence/EntityBundleStore.h"
#include "persistence/JsonFileAtomic.h"
#include <QDir>
#include <QFileInfo>
#include <QJsonArray>
#include <QJsonObject>
namespace core::persistence {
namespace {
QJsonArray pointsToJson(const QVector<QPointF>& pts) {
QJsonArray arr;
for (const auto& p : pts) {
QJsonObject o;
o.insert("x", p.x());
o.insert("y", p.y());
arr.append(o);
}
return arr;
}
bool pointsFromJson(const QJsonValue& v, QVector<QPointF>& out) {
out.clear();
if (!v.isArray()) return true;
const QJsonArray arr = v.toArray();
out.reserve(arr.size());
for (const auto& it : arr) {
if (!it.isObject()) continue;
const QJsonObject o = it.toObject();
out.push_back(QPointF(o.value("x").toDouble(0.0), o.value("y").toDouble(0.0)));
}
return true;
}
template <typename KeyT>
QJsonArray boolKeysToJson(const QVector<KeyT>& keys) {
QJsonArray arr;
for (const auto& k : keys) {
QJsonObject o;
o.insert("frame", k.frame);
o.insert("value", k.value);
arr.append(o);
}
return arr;
}
QJsonArray vec2KeysToJson(const QVector<Project::Entity::KeyframeVec2>& keys) {
QJsonArray arr;
for (const auto& k : keys) {
QJsonObject o;
o.insert("frame", k.frame);
o.insert("x", k.value.x());
o.insert("y", k.value.y());
arr.append(o);
}
return arr;
}
QJsonArray floatKeysToJson(const QVector<Project::Entity::KeyframeFloat01>& keys) {
QJsonArray arr;
for (const auto& k : keys) {
QJsonObject o;
o.insert("frame", k.frame);
o.insert("value", k.value);
arr.append(o);
}
return arr;
}
QJsonArray doubleKeysToJson(const QVector<Project::Entity::KeyframeDouble>& keys) {
QJsonArray arr;
for (const auto& k : keys) {
QJsonObject o;
o.insert("frame", k.frame);
o.insert("value", k.value);
arr.append(o);
}
return arr;
}
QJsonArray imageFramesToJson(const QVector<Project::Entity::ImageFrame>& keys) {
QJsonArray arr;
for (const auto& k : keys) {
QJsonObject o;
o.insert("frame", k.frame);
o.insert("path", k.imagePath);
arr.append(o);
}
return arr;
}
template <typename KeyT>
bool boolKeysFromJson(const QJsonValue& v, QVector<KeyT>& out) {
out.clear();
if (!v.isArray()) return true;
const QJsonArray arr = v.toArray();
out.reserve(arr.size());
for (const auto& it : arr) {
if (!it.isObject()) continue;
const QJsonObject o = it.toObject();
KeyT k;
k.frame = o.value("frame").toInt(0);
k.value = o.value("value").toBool(true);
out.push_back(k);
}
return true;
}
bool vec2KeysFromJson(const QJsonValue& v, QVector<Project::Entity::KeyframeVec2>& out) {
out.clear();
if (!v.isArray()) return true;
const QJsonArray arr = v.toArray();
out.reserve(arr.size());
for (const auto& it : arr) {
if (!it.isObject()) continue;
const QJsonObject o = it.toObject();
Project::Entity::KeyframeVec2 k;
k.frame = o.value("frame").toInt(0);
k.value = QPointF(o.value("x").toDouble(0.0), o.value("y").toDouble(0.0));
out.push_back(k);
}
return true;
}
bool floatKeysFromJson(const QJsonValue& v, QVector<Project::Entity::KeyframeFloat01>& out) {
out.clear();
if (!v.isArray()) return true;
const QJsonArray arr = v.toArray();
out.reserve(arr.size());
for (const auto& it : arr) {
if (!it.isObject()) continue;
const QJsonObject o = it.toObject();
Project::Entity::KeyframeFloat01 k;
k.frame = o.value("frame").toInt(0);
k.value = o.value("value").toDouble(0.5);
out.push_back(k);
}
return true;
}
bool doubleKeysFromJson(const QJsonValue& v, QVector<Project::Entity::KeyframeDouble>& out) {
out.clear();
if (!v.isArray()) return true;
const QJsonArray arr = v.toArray();
out.reserve(arr.size());
for (const auto& it : arr) {
if (!it.isObject()) continue;
const QJsonObject o = it.toObject();
Project::Entity::KeyframeDouble k;
k.frame = o.value("frame").toInt(0);
k.value = o.value("value").toDouble(1.0);
out.push_back(k);
}
return true;
}
bool imageFramesFromJson(const QJsonValue& v, QVector<Project::Entity::ImageFrame>& out) {
out.clear();
if (!v.isArray()) return true;
const QJsonArray arr = v.toArray();
out.reserve(arr.size());
for (const auto& it : arr) {
if (!it.isObject()) continue;
const QJsonObject o = it.toObject();
Project::Entity::ImageFrame k;
k.frame = o.value("frame").toInt(0);
k.imagePath = o.value("path").toString();
out.push_back(k);
}
return true;
}
QJsonObject introToJson(const core::EntityIntroContent& intro) {
QJsonObject o;
o.insert("title", intro.title);
o.insert("bodyText", intro.bodyText);
o.insert("videoPathRelative", intro.videoPathRelative);
QJsonArray imgs;
for (const auto& p : intro.imagePathsRelative) imgs.append(p);
o.insert("imagePathsRelative", imgs);
return o;
}
bool introFromJson(const QJsonObject& o, core::EntityIntroContent& out) {
out = core::EntityIntroContent{};
out.title = o.value("title").toString();
out.bodyText = o.value("bodyText").toString();
out.videoPathRelative = o.value("videoPathRelative").toString();
const QJsonValue imgsVal = o.value("imagePathsRelative");
if (imgsVal.isArray()) {
for (const auto& it : imgsVal.toArray()) {
const QString p = it.toString();
if (!p.isEmpty()) out.imagePathsRelative.push_back(p);
}
}
return true;
}
} // namespace
QString EntityBundleStore::bundleRelativeDir(const QString& entityId) {
if (entityId.isEmpty()) return {};
return QStringLiteral("assets/entities/%1").arg(entityId);
}
bool EntityBundleStore::save(const QString& projectDirAbs, const Project::Entity& entity) {
if (projectDirAbs.isEmpty() || entity.id.isEmpty()) {
return false;
}
const QString relDir = bundleRelativeDir(entity.id);
if (relDir.isEmpty()) return false;
const QString absDir = QDir(projectDirAbs).filePath(relDir);
QDir().mkpath(absDir);
// meta.json
QJsonObject meta;
meta.insert("id", entity.id);
meta.insert("displayName", entity.displayName);
meta.insert("visible", entity.visible);
meta.insert("originX", entity.originWorld.x());
meta.insert("originY", entity.originWorld.y());
meta.insert("depth", entity.depth);
meta.insert("priority", entity.priority);
meta.insert("imagePath", entity.imagePath);
meta.insert("imageTopLeftX", entity.imageTopLeftWorld.x());
meta.insert("imageTopLeftY", entity.imageTopLeftWorld.y());
meta.insert("userScale", entity.userScale);
meta.insert("distanceScaleCalibMult", entity.distanceScaleCalibMult);
meta.insert("ignoreDistanceScale", entity.ignoreDistanceScale);
meta.insert("parentId", entity.parentId);
meta.insert("parentOffsetX", entity.parentOffsetWorld.x());
meta.insert("parentOffsetY", entity.parentOffsetWorld.y());
meta.insert("polygonLocal", pointsToJson(entity.polygonLocal));
meta.insert("cutoutPolygonWorld", pointsToJson(entity.cutoutPolygonWorld));
meta.insert("blackholeId", entity.blackholeId);
meta.insert("blackholeVisible", entity.blackholeVisible);
meta.insert("blackholeResolvedBy", entity.blackholeResolvedBy);
meta.insert("blackholeOverlayPath", entity.blackholeOverlayPath);
meta.insert("blackholeOverlayRectX", entity.blackholeOverlayRect.x());
meta.insert("blackholeOverlayRectY", entity.blackholeOverlayRect.y());
meta.insert("blackholeOverlayRectW", entity.blackholeOverlayRect.width());
meta.insert("blackholeOverlayRectH", entity.blackholeOverlayRect.height());
if (!writeJsonAtomic(QDir(absDir).filePath(QStringLiteral("meta.json")), meta, true)) {
return false;
}
// anim.json
QJsonObject anim;
anim.insert("locationKeys", vec2KeysToJson(entity.locationKeys));
anim.insert("depthScaleKeys", floatKeysToJson(entity.depthScaleKeys));
anim.insert("userScaleKeys", doubleKeysToJson(entity.userScaleKeys));
anim.insert("visibilityKeys", boolKeysToJson<Project::ToolKeyframeBool>(entity.visibilityKeys));
anim.insert("imageFrames", imageFramesToJson(entity.imageFrames));
if (!writeJsonAtomic(QDir(absDir).filePath(QStringLiteral("anim.json")), anim, true)) {
return false;
}
// intro.json
if (!writeJsonAtomic(QDir(absDir).filePath(QStringLiteral("intro.json")), introToJson(entity.intro), true)) {
return false;
}
// default.png (可为空)
const QString pngAbs = QDir(absDir).filePath(QStringLiteral("default.png"));
if (!entity.defaultImagePng.isEmpty()) {
if (!writeBytesAtomic(pngAbs, entity.defaultImagePng)) {
return false;
}
} else {
// 清空时删掉，避免读到旧图
if (QFileInfo::exists(pngAbs)) {
QFile::remove(pngAbs);
}
}
return true;
}
bool EntityBundleStore::load(const QString& projectDirAbs, Project::Entity& inOutEntity) {
if (projectDirAbs.isEmpty() || inOutEntity.id.isEmpty()) {
return false;
}
const QString relDir = inOutEntity.entityPayloadPath;
if (relDir.isEmpty()) return false;
const QString absDir = QDir(projectDirAbs).filePath(relDir);
if (!QFileInfo(absDir).exists()) return false;
QJsonObject meta;
if (!readJsonObject(QDir(absDir).filePath(QStringLiteral("meta.json")), meta)) {
return false;
}
const QString id = meta.value("id").toString();
if (id.isEmpty() || id != inOutEntity.id) {
return false;
}
Project::Entity e = inOutEntity; // 保留 stub：id/payloadPath/visible 等必要字段会被覆盖
e.displayName = meta.value("displayName").toString();
e.visible = meta.value("visible").toBool(true);
e.originWorld = QPointF(meta.value("originX").toDouble(0.0), meta.value("originY").toDouble(0.0));
e.depth = meta.value("depth").toInt(0);
e.priority = meta.value("priority").toInt(1);
e.imagePath = meta.value("imagePath").toString();
e.imageTopLeftWorld = QPointF(meta.value("imageTopLeftX").toDouble(0.0), meta.value("imageTopLeftY").toDouble(0.0));
e.userScale = meta.value("userScale").toDouble(1.0);
e.distanceScaleCalibMult = meta.value("distanceScaleCalibMult").toDouble(0.0);
e.ignoreDistanceScale = meta.value("ignoreDistanceScale").toBool(false);
e.parentId = meta.value("parentId").toString();
e.parentOffsetWorld = QPointF(meta.value("parentOffsetX").toDouble(0.0), meta.value("parentOffsetY").toDouble(0.0));
pointsFromJson(meta.value("polygonLocal"), e.polygonLocal);
pointsFromJson(meta.value("cutoutPolygonWorld"), e.cutoutPolygonWorld);
e.blackholeId = meta.value("blackholeId").toString();
e.blackholeVisible = meta.value("blackholeVisible").toBool(true);
e.blackholeResolvedBy = meta.value("blackholeResolvedBy").toString();
e.blackholeOverlayPath = meta.value("blackholeOverlayPath").toString();
e.blackholeOverlayRect = QRect(meta.value("blackholeOverlayRectX").toInt(0),
meta.value("blackholeOverlayRectY").toInt(0),
meta.value("blackholeOverlayRectW").toInt(0),
meta.value("blackholeOverlayRectH").toInt(0));
QJsonObject anim;
if (!readJsonObject(QDir(absDir).filePath(QStringLiteral("anim.json")), anim)) {
return false;
}
vec2KeysFromJson(anim.value("locationKeys"), e.locationKeys);
floatKeysFromJson(anim.value("depthScaleKeys"), e.depthScaleKeys);
doubleKeysFromJson(anim.value("userScaleKeys"), e.userScaleKeys);
boolKeysFromJson<Project::ToolKeyframeBool>(anim.value("visibilityKeys"), e.visibilityKeys);
imageFramesFromJson(anim.value("imageFrames"), e.imageFrames);
QJsonObject intro;
if (!readJsonObject(QDir(absDir).filePath(QStringLiteral("intro.json")), intro)) {
return false;
}
introFromJson(intro, e.intro);
// default.png
const QString pngAbs = QDir(absDir).filePath(QStringLiteral("default.png"));
if (QFileInfo::exists(pngAbs)) {
QFile f(pngAbs);
if (f.open(QIODevice::ReadOnly)) {
e.defaultImagePng = f.readAll();
} else {
return false;
}
} else {
e.defaultImagePng.clear();
}
inOutEntity = std::move(e);
return true;
}
} // namespace core::persistence
client/core/persistence/EntityBundleStore.h
+22
View File
@@ -0,0 +1,22 @@
#pragma once
#include "domain/Project.h"
#include <QString>
namespace core::persistence {
/// 实体 payload 的目录 bundle 结构（v7 起）：
/// assets/entities/<id>/
/// meta.json // 静态字段（几何/层级/黑洞等）
/// anim.json // 关键帧轨道（location/depthScale/userScale/visibility/priority/sprite frames）
/// intro.json // intro
/// default.png // 默认贴图（可为空）
struct EntityBundleStore {
static QString bundleRelativeDir(const QString& entityId);
static bool save(const QString& projectDirAbs, const Project::Entity& entity);
static bool load(const QString& projectDirAbs, Project::Entity& inOutEntity);
};
} // namespace core::persistence
client/core/persistence/EntityPayloadBinary.cpp
+78 -137
View File
@@ -6,6 +6,7 @@
#include <QDataStream>
#include <QFile>
#include <QRect>
#include <QtGlobal>
#include <algorithm>
@@ -235,7 +236,9 @@ public:
const Project::Entity& entity = *m_src;
ds << entity.id;
ds << qint32(entity.depth);
ds << qint32(entity.priority);
ds << entity.imagePath;
ds << entity.defaultImagePng;
ds << double(entity.originWorld.x()) << double(entity.originWorld.y());
ds << double(entity.imageTopLeftWorld.x()) << double(entity.imageTopLeftWorld.y());
@@ -249,7 +252,6 @@ public:
ds << double(pt.x()) << double(pt.y());
}
writeAnimationBlock(ds, entity, true);
ds << entity.displayName << double(entity.userScale) << double(entity.distanceScaleCalibMult);
ds << bool(entity.ignoreDistanceScale);
ds << entity.parentId;
@@ -267,14 +269,65 @@ public:
: entity.blackholeId;
ds << holeId;
ds << entity.blackholeResolvedBy;
ds << entity.blackholeOverlayPath;
ds << qint32(entity.blackholeOverlayRect.x()) << qint32(entity.blackholeOverlayRect.y())
<< qint32(entity.blackholeOverlayRect.width()) << qint32(entity.blackholeOverlayRect.height());
}
bool readBody(QDataStream& ds) override {
Q_ASSERT(m_dst != nullptr);
const quint32 fileVer = loadedRecordFormatVersion();
Project::Entity tmp;
if (!readEntityPayloadV1(ds, tmp, true)) {
ds >> tmp.id;
qint32 depth = 0;
ds >> depth;
tmp.depth = static_cast<int>(depth);
qint32 pri = 1;
if (fileVer >= 12) {
ds >> pri;
}
tmp.priority = int(pri);
ds >> tmp.imagePath;
if (fileVer >= 13) {
ds >> tmp.defaultImagePng;
} else {
tmp.defaultImagePng.clear();
}
double ox = 0.0;
double oy = 0.0;
double itlx = 0.0;
double itly = 0.0;
ds >> ox >> oy >> itlx >> itly;
tmp.originWorld = QPointF(ox, oy);
tmp.imageTopLeftWorld = QPointF(itlx, itly);
qint32 nLocal = 0;
ds >> nLocal;
if (ds.status() != QDataStream::Ok || nLocal < 0 || nLocal > 1000000) return false;
tmp.polygonLocal.reserve(nLocal);
for (qint32 i = 0; i < nLocal; ++i) {
double x = 0.0;
double y = 0.0;
ds >> x >> y;
if (ds.status() != QDataStream::Ok) return false;
tmp.polygonLocal.push_back(QPointF(x, y));
}
qint32 nCut = 0;
ds >> nCut;
if (ds.status() != QDataStream::Ok || nCut < 0 || nCut > 1000000) return false;
tmp.cutoutPolygonWorld.reserve(nCut);
for (qint32 i = 0; i < nCut; ++i) {
double x = 0.0;
double y = 0.0;
ds >> x >> y;
if (ds.status() != QDataStream::Ok) return false;
tmp.cutoutPolygonWorld.push_back(QPointF(x, y));
}
if (tmp.id.isEmpty() || tmp.polygonLocal.isEmpty()) {
return false;
}
QString dn;
double us = 1.0;
double cal = 0.0;
@@ -298,27 +351,23 @@ public:
tmp.parentOffsetWorld = QPointF(pox, poy);
// v7：实体可见性关键帧
tmp.visibilityKeys.clear();
qint32 nVis = 0;
ds >> nVis;
if (ds.status() != QDataStream::Ok) {
if (ds.status() != QDataStream::Ok || nVis < 0 || nVis > 1000000) {
return false;
}
tmp.visibilityKeys.clear();
if (nVis > 0) {
tmp.visibilityKeys.reserve(nVis);
for (qint32 i = 0; i < nVis; ++i) {
qint32 fr = 0;
bool val = true;
ds >> fr >> val;
if (ds.status() != QDataStream::Ok) {
return false;
}
core::Project::ToolKeyframeBool k;
k.frame = int(fr);
k.value = val;
tmp.visibilityKeys.push_back(k);
tmp.visibilityKeys.reserve(nVis);
for (qint32 i = 0; i < nVis; ++i) {
qint32 fr = 0;
bool vis = true;
ds >> fr >> vis;
if (ds.status() != QDataStream::Ok) {
return false;
}
tmp.visibilityKeys.push_back(Project::ToolKeyframeBool{int(fr), vis});
}
if (!readIntroBlock(ds, tmp.intro)) {
return false;
}
@@ -332,6 +381,17 @@ public:
tmp.blackholeVisible = holeVisible;
tmp.blackholeId = holeId.isEmpty() ? QStringLiteral("blackhole-%1").arg(tmp.id) : holeId;
tmp.blackholeResolvedBy = resolvedBy;
QString overlayPath;
qint32 rectX = 0;
qint32 rectY = 0;
qint32 ow = 0;
qint32 oh = 0;
ds >> overlayPath >> rectX >> rectY >> ow >> oh;
if (ds.status() != QDataStream::Ok) {
return false;
}
tmp.blackholeOverlayPath = overlayPath;
tmp.blackholeOverlayRect = QRect(int(rectX), int(rectY), int(ow), int(oh));
*m_dst = std::move(tmp);
return true;
}
@@ -376,126 +436,7 @@ bool EntityPayloadBinary::save(const QString& absolutePath, const Project::Entit
}
bool EntityPayloadBinary::load(const QString& absolutePath, Project::Entity& entity) {
QFile f(absolutePath);
if (!f.open(QIODevice::ReadOnly)) {
return false;
}
QDataStream ds(&f);
ds.setVersion(QDataStream::Qt_5_15);
quint32 magic = 0;
quint32 ver = 0;
ds >> magic >> ver;
if (ds.status() != QDataStream::Ok || magic != kMagicPayload) {
return false;
}
if (ver != 1 && ver != 2 && ver != 3 && ver != 4 && ver != 5 && ver != 6 && ver != 7 && ver != 8 && ver != 9) {
return false;
}
Project::Entity tmp;
if (!readEntityPayloadV1(ds, tmp, ver >= 3)) {
return false;
}
if (ver >= 2) {
QString dn;
double us = 1.0;
ds >> dn >> us;
if (ds.status() != QDataStream::Ok) {
return false;
}
tmp.displayName = dn;
tmp.userScale = std::clamp(us, 1e-3, 1e3);
if (ver >= 4) {
double cal = 0.0;
ds >> cal;
if (ds.status() != QDataStream::Ok) {
return false;
}
tmp.distanceScaleCalibMult = (cal > 0.0) ? std::clamp(cal, 1e-6, 10.0) : 0.0;
}
if (ver >= 6) {
bool ign = false;
QString pid;
double pox = 0.0;
double poy = 0.0;
ds >> ign >> pid >> pox >> poy;
if (ds.status() != QDataStream::Ok) {
return false;
}
tmp.ignoreDistanceScale = ign;
tmp.parentId = pid;
tmp.parentOffsetWorld = QPointF(pox, poy);
} else {
tmp.ignoreDistanceScale = false;
tmp.parentId.clear();
tmp.parentOffsetWorld = QPointF();
}
if (ver >= 7) {
qint32 nVis = 0;
ds >> nVis;
if (ds.status() != QDataStream::Ok) {
return false;
}
tmp.visibilityKeys.clear();
if (nVis > 0) {
tmp.visibilityKeys.reserve(nVis);
for (qint32 i = 0; i < nVis; ++i) {
qint32 fr = 0;
bool val = true;
ds >> fr >> val;
if (ds.status() != QDataStream::Ok) {
return false;
}
core::Project::ToolKeyframeBool k;
k.frame = int(fr);
k.value = val;
tmp.visibilityKeys.push_back(k);
}
}
} else {
tmp.visibilityKeys.clear();
}
if (ver >= 5) {
if (!readIntroBlock(ds, tmp.intro)) {
return false;
}
}
if (ver >= 8) {
bool holeVisible = true;
QString holeId;
ds >> holeVisible >> holeId;
if (ds.status() != QDataStream::Ok) {
return false;
}
tmp.blackholeVisible = holeVisible;
tmp.blackholeId = holeId.isEmpty() ? QStringLiteral("blackhole-%1").arg(tmp.id) : holeId;
if (ver >= 9) {
QString resolvedBy;
ds >> resolvedBy;
if (ds.status() != QDataStream::Ok) {
return false;
}
tmp.blackholeResolvedBy = resolvedBy;
} else {
tmp.blackholeResolvedBy = QStringLiteral("pending");
}
} else {
tmp.blackholeVisible = true;
tmp.blackholeId = QStringLiteral("blackhole-%1").arg(tmp.id);
tmp.blackholeResolvedBy = QStringLiteral("pending");
}
} else {
tmp.displayName.clear();
tmp.userScale = 1.0;
tmp.ignoreDistanceScale = false;
tmp.parentId.clear();
tmp.parentOffsetWorld = QPointF();
tmp.visibilityKeys.clear();
tmp.blackholeVisible = true;
tmp.blackholeId = QStringLiteral("blackhole-%1").arg(tmp.id);
tmp.blackholeResolvedBy = QStringLiteral("pending");
}
entity = std::move(tmp);
return true;
return EntityBinaryRecord(entity).loadFromFile(absolutePath);
}
bool EntityPayloadBinary::loadLegacyAnimFile(const QString& absolutePath, Project::Entity& entity) {
client/core/persistence/EntityPayloadBinary.h
+2 -2
View File
@@ -7,12 +7,12 @@
namespace core {
// 实体完整数据（几何 + 贴图路径 + 动画轨道）的二进制格式，与 project.json v2 的 payload 字段对应。
// 贴图 PNG 仍单独存放在 assets/entities/，本文件不嵌入像素。
// 默认贴图 PNG 存在本文件中（PNG bytes），不兼容旧路径工程。
// 具体读写通过继承 PersistentBinaryObject 的适配器类完成（见 EntityPayloadBinary.cpp）。
class EntityPayloadBinary {
public:
static constexpr quint32 kMagicPayload = 0x48464550; // 'HFEP'
static constexpr quint32 kPayloadVersion = 9; // v9：追加 blackholeResolvedBy
static constexpr quint32 kPayloadVersion = 13; // v13：默认贴图存 PNG bytes
// 旧版独立动画文件（仍用于打开 v1 项目时合并）
static constexpr quint32 kMagicLegacyAnim = 0x48465441; // 'HFTA'
client/core/persistence/JsonFileAtomic.cpp
+62
View File
@@ -0,0 +1,62 @@
#include "persistence/JsonFileAtomic.h"
#include <QDir>
#include <QFile>
#include <QFileInfo>
namespace core::persistence {
bool writeBytesAtomic(const QString& absolutePath, const QByteArray& bytes) {
if (absolutePath.isEmpty()) {
return false;
}
const QString parent = QFileInfo(absolutePath).absolutePath();
if (!QFileInfo(parent).exists()) {
QDir().mkpath(parent);
}
const QString tmpAbs = absolutePath + QStringLiteral(".tmp");
if (QFileInfo::exists(tmpAbs)) {
QFile::remove(tmpAbs);
}
QFile f(tmpAbs);
if (!f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
return false;
}
const bool ok = f.write(bytes) == bytes.size();
f.close();
if (!ok || f.error() != QFile::NoError) {
QFile::remove(tmpAbs);
return false;
}
QFile::remove(absolutePath);
if (!QFile::rename(tmpAbs, absolutePath)) {
QFile::remove(tmpAbs);
return false;
}
return true;
}
bool writeJsonAtomic(const QString& absolutePath, const QJsonObject& obj, bool pretty) {
const QJsonDocument doc(obj);
const QByteArray bytes = doc.toJson(pretty ? QJsonDocument::Indented : QJsonDocument::Compact);
return writeBytesAtomic(absolutePath, bytes);
}
bool readJsonObject(const QString& absolutePath, QJsonObject& out) {
out = QJsonObject();
QFile f(absolutePath);
if (!f.open(QIODevice::ReadOnly)) {
return false;
}
const QByteArray data = f.readAll();
QJsonParseError err;
const QJsonDocument doc = QJsonDocument::fromJson(data, &err);
if (err.error != QJsonParseError::NoError || !doc.isObject()) {
return false;
}
out = doc.object();
return true;
}
} // namespace core::persistence
client/core/persistence/JsonFileAtomic.h
+20
View File
@@ -0,0 +1,20 @@
#pragma once
#include <QByteArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QString>
namespace core::persistence {
/// 原子写 JSON：写入 .tmp 后 rename 覆盖，避免截断导致下次打开“损坏”。
bool writeJsonAtomic(const QString& absolutePath, const QJsonObject& obj, bool pretty = true);
/// 读取 JSON 文件（必须为 object）。失败返回 false。
bool readJsonObject(const QString& absolutePath, QJsonObject& out);
/// 原子写 bytes：写入 .tmp 后 rename 覆盖。
bool writeBytesAtomic(const QString& absolutePath, const QByteArray& bytes);
} // namespace core::persistence
client/core/persistence/PersistentBinaryObject.cpp
+3 -1
View File
@@ -48,9 +48,11 @@ bool PersistentBinaryObject::loadFromFile(const QString& absolutePath) {
quint32 magic = 0;
quint32 version = 0;
ds >> magic >> version;
if (ds.status() != QDataStream::Ok || magic != recordMagic() || version != recordFormatVersion()) {
const quint32 cur = recordFormatVersion();
if (ds.status() != QDataStream::Ok || magic != recordMagic() || version < 1 || version > cur) {
return false;
}
m_loadedVersion = version;
return readBody(ds);
}
client/core/persistence/PersistentBinaryObject.h
+6
View File
@@ -22,6 +22,12 @@ protected:
virtual quint32 recordFormatVersion() const = 0;
virtual void writeBody(QDataStream& ds) const = 0;
virtual bool readBody(QDataStream& ds) = 0;
/// 读取文件时解析到的版本号（<= recordFormatVersion）。用于向后兼容读取分支。
[[nodiscard]] quint32 loadedRecordFormatVersion() const { return m_loadedVersion; }
private:
quint32 m_loadedVersion = 0;
};
} // namespace core
client/core/workspace/ProjectWorkspace.cpp
+1806 -941
View File
File diff suppressed because it is too large Load Diff
client/core/workspace/ProjectWorkspace.h
+73 -7
View File
@@ -5,19 +5,24 @@
#include <QImage>
#include <QJsonObject>
#include <QRect>
#include <QSet>
#include <QTimer>
#include <QString>
#include <QStringList>
#include <QVector>
#include <QPoint>
namespace core {
namespace persistence {
class AsyncProjectWriter;
}
class ProjectWorkspace {
public:
static constexpr const char* kProjectIndexFileName = "project.json";
static constexpr const char* kAssetsDirName = "assets";
// 写入 project.json 的 version 字段；仍可读 version 1（内嵌实体 + 可选 .anim）。
static constexpr int kProjectIndexFormatVersion = 4;
static constexpr int kProjectIndexFormatVersion = 7;
ProjectWorkspace() = default;
@@ -58,6 +63,7 @@ public:
// 仅写盘（project.json + payload 同步）。动画 UI 直接编辑 Project 后可调用此函数持久化。
bool save();
bool saveAll();
// 历史操作（最多 30 步），类似 Blender：维护 undo/redo 栈
bool canUndo() const;
@@ -92,6 +98,7 @@ public:
bool setToolFontPx(const QString& id, int fontPx);
bool setToolAlign(const QString& id, core::Project::Tool::TextAlign align);
bool setToolVisibilityKey(const QString& id, int frame, bool visible);
bool setToolPriorityKey(const QString& id, int frame, int priority);
bool removeToolVisibilityKey(const QString& id, int frame);
bool setToolParent(const QString& id, const QString& parentId, const QPointF& parentOffsetWorld);
bool moveToolBy(const QString& id, const QPointF& delta, int currentFrame, bool autoKeyLocation);
@@ -113,9 +120,9 @@ public:
// 复制背景其他区域填充黑洞（sourceOffsetPx 以黑洞包围盒左上角为基准偏移）
bool resolveBlackholeByCopyBackground(const QString& id, const QPoint& sourceOffsetPx,
bool hideBlackholeAfterFill);
// 使用模型补全后的结果写回背景（patchedBackground 已包含补全贴合后的完整背景图像）
bool resolveBlackholeByModelInpaint(const QString& id, const QImage& patchedBackground,
bool hideBlackholeAfterFill);
// 将模型补全的裁剪块保存为覆盖层并叠加显示，不修改 background 原图
bool resolveBlackholeByModelInpaint(const QString& id, const QImage& overlayPatch,
const QRect& overlayRectInBackground, bool hideBlackholeAfterFill);
bool setEntityVisibilityKey(const QString& id, int frame, bool visible);
bool removeEntityVisibilityKey(const QString& id, int frame);
bool setEntityDisplayName(const QString& id, const QString& displayName);
@@ -126,17 +133,42 @@ public:
// 将多边形质心平移到 targetCentroidWorld（整体平移）；sTotal 须与画布一致
bool moveEntityCentroidTo(const QString& id, int frame, const QPointF& targetCentroidWorld, double sTotal,
bool autoKeyLocation);
/// 仅适用于有父实体：设置相对父形心的偏移（静态 parentOffsetWorld）。
bool setEntityParentOffsetWorld(const QString& id, const QPointF& offsetWorld);
// 在保持外形不变的前提下移动枢轴点；sTotal 须与画布一致（距离缩放×整体缩放）
bool reanchorEntityPivot(const QString& id, int frame, const QPointF& newPivotWorld, double sTotal);
/// 将各实体 origin 与多边形形心对齐（外形不变）；打开工程时迁移旧数据。
bool normalizeAllEntityOriginsToCentroids(int frame);
/// 当前帧下实体多边形形心的世界坐标（与画布深度/距离缩放采样点一致）；工具 id 则返回其原点。
[[nodiscard]] QPointF entityCentroidWorldAtFrame(const QString& id, int frame) const;
bool reorderEntitiesById(const QStringList& idsInOrder);
// currentFrame：自动关键帧时写入位置曲线；autoKeyLocation 为 false 时忽略。
bool moveEntityBy(const QString& id, const QPointF& delta, int currentFrame, bool autoKeyLocation);
bool setEntityLocationKey(const QString& id, int frame, const QPointF& originWorld);
bool setEntityDepthScaleKey(const QString& id, int frame, double value01);
bool setEntityUserScaleKey(const QString& id, int frame, double userScale);
bool setEntityPriorityKey(const QString& id, int frame, int priority);
bool setEntityDefaultImage(const QString& id, const QImage& image, QString* outRelPath = nullptr);
bool setEntityImageFrame(const QString& id, int frame, const QImage& image, QString* outRelPath = nullptr);
// 仅更新 imageFrames 中某帧的图像路径（不读图、不写盘），用于高性能地“切断”Hold 区间
bool setEntityImageFramePath(const QString& id, int frame, const QString& relativePath);
QVector<Project::Entity::ImageFrame> entitySpriteFrames(const QString& id) const;
QString entityImagePathAt(const QString& id, int frame) const;
QByteArray entityImagePngAt(const QString& id, int frame) const;
bool clearEntityImageFramesInRange(const QString& id, int startFrame, int endFrame);
int activeAnimationLengthFrames() const;
int activeAnimationFps() const;
int animationLengthFramesForId(const QString& animationId) const;
int animationFpsForId(const QString& animationId) const;
bool animationLoopsForId(const QString& animationId) const;
bool createAnimationScheme(const QString& displayName, int lengthFrames, bool loop, int fps,
QString* outNewId = nullptr);
bool updateAnimationSchemeSettings(const QString& id, const QString& displayName, int lengthFrames, bool loop,
int fps);
bool applyPresentationHotspots(const QVector<Project::PresentationHotspot>& hotspots, bool recordHistory,
const QString& label);
bool removeEntityLocationKey(const QString& id, int frame);
bool removeEntityDepthScaleKey(const QString& id, int frame);
bool removeEntityUserScaleKey(const QString& id, int frame);
@@ -152,8 +184,9 @@ private:
bool readIndexJson(const QString& indexPath);
bool syncEntityPayloadsToDisk();
bool syncAnimationPayloadsToDisk();
bool hydrateEntityPayloadsFromDisk();
void loadV1LegacyAnimationSidecars();
bool hydrateAnimationPayloadsFromDisk();
bool writeIndexJsonWithoutPayloadSync();
bool saveSingleEntityPayload(Project::Entity& entity);
@@ -163,7 +196,6 @@ private:
static QString fileSuffixWithDot(const QString& path);
static QString asOptionalRelativeUnderProject(const QString& relativePath);
static QJsonObject entityToJson(const Project::Entity& e);
static bool entityFromJsonV1(const QJsonObject& o, Project::Entity& out);
static bool entityStubFromJsonV2(const QJsonObject& o, Project::Entity& out);
static QJsonObject toolToJson(const Project::Tool& t);
static bool toolFromJsonV2(const QJsonObject& o, Project::Tool& out);
@@ -174,7 +206,16 @@ private:
bool ensureDefaultCameraIfMissing(bool* outAdded = nullptr);
struct Operation {
enum class Type { ImportBackground, SetEntities, SetTools, SetCameras, SetProjectTitle, SetProjectFrameRange };
enum class Type {
ImportBackground,
SetEntities,
SetTools,
SetCameras,
SetAnimations,
SetPresentationHotspots,
SetProjectTitle,
SetProjectFrameRange
};
Type type {Type::ImportBackground};
QString label;
QString beforeBackgroundPath;
@@ -185,6 +226,14 @@ private:
QVector<Project::Tool> afterTools;
QVector<Project::Camera> beforeCameras;
QVector<Project::Camera> afterCameras;
QVector<Project::Animation> beforeAnimations;
QVector<Project::Animation> afterAnimations;
bool animBundlesPresentationHotspots = false;
QVector<Project::PresentationHotspot> animSnapshotBeforePresentationHotspots;
QVector<Project::PresentationHotspot> animSnapshotAfterPresentationHotspots;
QVector<Project::PresentationHotspot> beforePresentationHotspots;
QVector<Project::PresentationHotspot> afterPresentationHotspots;
QString beforeProjectTitle;
QString afterProjectTitle;
int beforeFrameStart = 0;
@@ -200,19 +249,36 @@ private:
bool applyEntities(const QVector<Project::Entity>& entities, bool recordHistory, const QString& label);
bool applyTools(const QVector<Project::Tool>& tools, bool recordHistory, const QString& label);
bool applyCameras(const QVector<Project::Camera>& cameras, bool recordHistory, const QString& label);
bool applyAnimations(const QVector<Project::Animation>& animations, bool recordHistory, const QString& label);
QString copyIntoAssetsAsBackground(const QString& sourceFilePath, const QRect& cropRectInSourceImage);
bool writeDepthMap(const QImage& depth8);
bool writeDepthMapBytes(const QByteArray& pngBytes);
QString ensureEntitiesDir() const;
QString ensureAnimationsDir() const;
bool writeEntityImage(const QString& entityId, const QImage& image, QString& outRelPath);
bool writeEntityFrameImage(const QString& entityId, int frame, const QImage& image, QString& outRelPath);
QString defaultAnimationPayloadPath(const QString& animationId) const;
void markIndexDirty();
/// snapshot：在尚未写入 m_project 前（例如新实体）必须传入，否则异步 bundle 写会漏队列。
void markEntityDirty(const QString& id, const Project::Entity* snapshot = nullptr);
void markAnimationDirty(const QString& id);
void markAllEntitiesDirty();
void markAllAnimationsDirty();
void schedulePayloadSync();
bool syncPayloadsToDiskOnce();
private:
QString m_projectDir;
Project m_project;
persistence::AsyncProjectWriter* m_asyncWriter = nullptr;
QVector<Operation> m_undoStack;
QVector<Operation> m_redoStack;
QSet<QString> m_dirtyEntityIds;
QSet<QString> m_dirtyAnimationIds;
bool m_indexDirty = false;
QTimer* m_payloadSyncTimer = nullptr;
};
} // namespace core
client/gui/CMakeLists.txt
+11
View File
@@ -3,14 +3,18 @@ set(GUI_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
set(GUI_SOURCES
${GUI_ROOT}/app/main.cpp
${GUI_ROOT}/app/AppStyle.cpp
${GUI_ROOT}/main_window/MainWindow.cpp
${GUI_ROOT}/library/ResourceLibraryDock.cpp
${GUI_ROOT}/widgets/LongPressSwitchToolButton.cpp
${GUI_ROOT}/widgets/ToolOptionPopup.cpp
${GUI_ROOT}/widgets/CompactNumericSpinBox.cpp
${GUI_ROOT}/widgets/PropertyPanelControls.cpp
${GUI_ROOT}/main_window/RecentProjectHistory.cpp
${GUI_ROOT}/dialogs/AboutWindow.cpp
${GUI_ROOT}/dialogs/ImageCropDialog.cpp
${GUI_ROOT}/dialogs/FrameAnimationDialog.cpp
${GUI_ROOT}/dialogs/AnimationSchemeSettingsDialog.cpp
${GUI_ROOT}/dialogs/CancelableTaskDialog.cpp
${GUI_ROOT}/dialogs/EntityFinalizeDialog.cpp
${GUI_ROOT}/dialogs/BlackholeResolveDialog.cpp
@@ -24,18 +28,23 @@ set(GUI_SOURCES
${GUI_ROOT}/props/EntityPropertySection.cpp
${GUI_ROOT}/props/ToolPropertySection.cpp
${GUI_ROOT}/props/CameraPropertySection.cpp
${GUI_ROOT}/props/HotspotPropertySection.cpp
${GUI_ROOT}/timeline/TimelineWidget.cpp
)
set(GUI_HEADERS
${GUI_ROOT}/main_window/MainWindow.h
${GUI_ROOT}/app/AppStyle.h
${GUI_ROOT}/library/ResourceLibraryDock.h
${GUI_ROOT}/widgets/LongPressSwitchToolButton.h
${GUI_ROOT}/widgets/ToolOptionPopup.h
${GUI_ROOT}/widgets/PropertyPanelControls.h
${GUI_ROOT}/widgets/CompactNumericSpinBox.h
${GUI_ROOT}/main_window/RecentProjectHistory.h
${GUI_ROOT}/dialogs/AboutWindow.h
${GUI_ROOT}/dialogs/ImageCropDialog.h
${GUI_ROOT}/dialogs/FrameAnimationDialog.h
${GUI_ROOT}/dialogs/AnimationSchemeSettingsDialog.h
${GUI_ROOT}/dialogs/CancelableTaskDialog.h
${GUI_ROOT}/dialogs/EntityFinalizeDialog.h
${GUI_ROOT}/dialogs/BlackholeResolveDialog.h
@@ -49,6 +58,7 @@ set(GUI_HEADERS
${GUI_ROOT}/props/EntityPropertySection.h
${GUI_ROOT}/props/ToolPropertySection.h
${GUI_ROOT}/props/CameraPropertySection.h
${GUI_ROOT}/props/HotspotPropertySection.h
${GUI_ROOT}/props/PropertySectionWidget.h
${GUI_ROOT}/timeline/TimelineWidget.h
)
@@ -76,6 +86,7 @@ target_link_libraries(LandscapeInteractiveToolApp
${QT_PACKAGE}::Core
${QT_PACKAGE}::Gui
${QT_PACKAGE}::Widgets
${QT_PACKAGE}::Concurrent
core
)
client/gui/app/AppStyle.cpp
+561
View File
@@ -0,0 +1,561 @@
#include "app/AppStyle.h"
namespace gui {
QString appStyleSheet() {
return QStringLiteral(R"QSS(
QWidget {
font-size: 13px;
}
/* ===== 属性面板容器 ===== */
#PropertyDockContent {
background: #f8f9fb;
}
/* 属性面板标签：清晰可读 */
#PropertyDockContent QLabel {
font-size: 12px;
color: #374151;
font-weight: 500;
}
#PropertyDockContent #PropertyPanelHeading {
font-size: 13px;
font-weight: 700;
color: #111827;
padding: 4px 0 2px 0;
}
/* 属性面板单行编辑 */
#PropertyDockContent #PropertyPanelLineEdit {
font-size: 12px;
border-radius: 6px;
padding: 4px 8px;
min-height: 22px;
max-height: 26px;
background: #ffffff;
border: 1px solid #d1d5db;
selection-background-color: rgba(59, 130, 246, 0.20);
}
#PropertyDockContent #PropertyPanelLineEdit:hover {
border: 1px solid #9ca3af;
}
#PropertyDockContent #PropertyPanelLineEdit:focus {
border: 1px solid #3b82f6;
background: #ffffff;
}
/* 属性面板下拉框 */
#PropertyDockContent #PropertyPanelComboBox {
font-size: 12px;
border-radius: 6px;
padding: 4px 8px;
min-height: 22px;
max-height: 26px;
background: #ffffff;
border: 1px solid #d1d5db;
}
#PropertyDockContent #PropertyPanelComboBox:hover {
border: 1px solid #9ca3af;
}
#PropertyDockContent #PropertyPanelComboBox:focus {
border: 1px solid #3b82f6;
}
#PropertyDockContent #PropertyPanelComboBox::drop-down {
width: 18px;
border: 0;
}
#PropertyDockContent #PropertyPanelComboBox::down-arrow {
image: none;
border-left: 4px solid transparent;
border-right: 4px solid transparent;
border-top: 5px solid #6b7280;
width: 0;
height: 0;
}
/* 属性面板多行编辑 */
#PropertyDockContent #PropertyPanelTextEdit {
font-size: 12px;
border-radius: 6px;
padding: 6px 8px;
background: #ffffff;
border: 1px solid #d1d5db;
selection-background-color: rgba(59, 130, 246, 0.20);
}
#PropertyDockContent #PropertyPanelTextEdit:hover {
border: 1px solid #9ca3af;
}
#PropertyDockContent #PropertyPanelTextEdit:focus {
border: 1px solid #3b82f6;
}
/* 属性面板按钮 */
#PropertyDockContent #PropertyPanelPushButton {
font-size: 12px;
font-weight: 500;
border-radius: 6px;
padding: 3px 12px;
min-height: 24px;
max-height: 26px;
background: #ffffff;
border: 1px solid #d1d5db;
color: #374151;
}
#PropertyDockContent #PropertyPanelPushButton:hover {
background: #eef2ff;
border: 1px solid #93b4fc;
color: #1d4ed8;
}
#PropertyDockContent #PropertyPanelPushButton:pressed {
background: #dbeafe;
border: 1px solid #60a5fa;
}
/* 属性面板复选框 */
#PropertyDockContent #PropertyPanelCheckBox {
font-size: 12px;
spacing: 6px;
color: #374151;
}
#PropertyDockContent #PropertyPanelCheckBox::indicator {
width: 16px;
height: 16px;
border-radius: 4px;
border: 1.5px solid #9ca3af;
background: #ffffff;
}
#PropertyDockContent #PropertyPanelCheckBox::indicator:hover {
border: 1.5px solid #3b82f6;
}
#PropertyDockContent #PropertyPanelCheckBox::indicator:checked {
background: #3b82f6;
border: 1.5px solid #2563eb;
}
/* 属性面板列表 */
#PropertyDockContent #PropertyPanelListWidget {
font-size: 12px;
border-radius: 6px;
padding: 4px;
background: #ffffff;
border: 1px solid #d1d5db;
}
#PropertyDockContent #PropertyPanelListWidget::item {
padding: 4px 8px;
border-radius: 4px;
}
#PropertyDockContent #PropertyPanelListWidget::item:selected {
background: rgba(59, 130, 246, 0.12);
color: #111827;
}
/* 属性面板紧凑数值框 */
#PropertyDockContent #CompactNumericSpin {
font-size: 12px;
border-radius: 6px;
padding: 0px;
min-height: 22px;
max-height: 26px;
background: #ffffff;
border: 1px solid #d1d5db;
}
#PropertyDockContent #CompactNumericSpin:hover {
border: 1px solid #9ca3af;
}
#PropertyDockContent #CompactNumericSpin:focus {
border: 1px solid #3b82f6;
}
#PropertyDockContent #CompactNumericSpin QLineEdit {
padding: 0px 4px;
margin: 0px;
min-height: 20px;
border: none;
background: transparent;
}
#PropertyDockContent #CompactNumericSpin::up-button,
#PropertyDockContent #CompactNumericSpin::down-button {
width: 14px;
border-left: 1px solid #e5e7eb;
background: #f9fafb;
}
#PropertyDockContent #CompactNumericSpin::up-button:hover,
#PropertyDockContent #CompactNumericSpin::down-button:hover {
background: #eef2ff;
}
/* 属性面板滑块 */
#PropertyDockContent QSlider::groove:horizontal {
height: 4px;
border-radius: 2px;
background: #e5e7eb;
}
#PropertyDockContent QSlider::handle:horizontal {
width: 14px;
height: 14px;
margin: -5px 0;
border-radius: 7px;
background: #ffffff;
border: 1.5px solid #d1d5db;
}
#PropertyDockContent QSlider::handle:horizontal:hover {
border: 1.5px solid #3b82f6;
background: #eef2ff;
}
/* 属性面板分割线 */
#PropertySectionSeparator {
max-height: 1px;
min-height: 1px;
background: #e5e7eb;
}
/* 全局紧凑数值框（非属性面板内） */
#CompactNumericSpin {
font-size: 12px;
border-radius: 6px;
padding: 0px;
min-height: 22px;
border: 1px solid #d1d5db;
background: #ffffff;
}
#CompactNumericSpin QLineEdit {
padding: 0px 4px;
margin: 0px;
min-height: 20px;
border: none;
background: transparent;
}
#CompactNumericSpin::up-button,
#CompactNumericSpin::down-button {
width: 14px;
border-left: 1px solid #e5e7eb;
background: #f9fafb;
}
#CompactNumericSpin::up-button:hover,
#CompactNumericSpin::down-button:hover {
background: #eef2ff;
}
/* ===== 主窗口 ===== */
QMainWindow {
background: #f3f4f6;
}
/* ===== 欢迎页 ===== */
#WelcomePage {
background: #f3f4f6;
}
#WelcomeCard {
background: #ffffff;
border: 1px solid #e5e7eb;
border-radius: 16px;
}
#WelcomeTitle {
font-size: 24px;
font-weight: 800;
color: #111827;
}
#WelcomeSectionTitle {
font-size: 15px;
font-weight: 700;
color: #111827;
}
#WelcomeDesc, #WelcomeHint {
color: #6b7280;
}
#WelcomePrimaryButton {
background: #3b82f6;
border: 1px solid #3b82f6;
color: #ffffff;
border-radius: 10px;
font-weight: 600;
padding: 8px 24px;
}
#WelcomePrimaryButton:hover {
background: #2563eb;
border: 1px solid #2563eb;
}
/* ===== 项目树眼睛按钮 ===== */
#ProjectTreeEyeButton {
border: 1.5px solid transparent;
border-radius: 6px;
padding: 0px;
color: #6b7280;
background: transparent;
font-weight: 600;
}
#ProjectTreeEyeButton:hover {
background: rgba(59, 130, 246, 0.08);
color: #3b82f6;
border: 1.5px solid rgba(59, 130, 246, 0.20);
}
#ProjectTreeEyeButton:checked {
color: #3b82f6;
background: rgba(59, 130, 246, 0.06);
}
/* ===== 项目树 ===== */
#ProjectTreeDockContent {
background: #f8f9fb;
}
#ProjectTree {
background: transparent;
border: none;
outline: 0;
}
#ProjectTree::item {
padding: 5px 8px;
border-radius: 6px;
color: #374151;
}
#ProjectTree::item:hover {
background: rgba(59, 130, 246, 0.06);
}
#ProjectTree::item:selected {
background: rgba(59, 130, 246, 0.10);
color: #111827;
border: none;
}
#ProjectTree::branch {
border: none;
}
/* ===== 停靠窗口 ===== */
QDockWidget {
titlebar-close-icon: none;
titlebar-normal-icon: none;
}
QDockWidget::title {
background: #ffffff;
padding: 8px 14px;
font-size: 13px;
font-weight: 700;
color: #111827;
border-bottom: 1px solid #e5e7eb;
}
/* 通用标签 */
QLabel {
color: #111827;
}
/* ===== 分组框 ===== */
QGroupBox {
border: 1px solid #e5e7eb;
border-radius: 10px;
margin-top: 14px;
background: #ffffff;
padding: 12px 8px 8px 8px;
}
QGroupBox::title {
subcontrol-origin: margin;
left: 12px;
padding: 0 8px;
color: #374151;
font-weight: 600;
font-size: 12px;
}
/* ===== 通用输入控件 ===== */
QLineEdit, QTextEdit, QPlainTextEdit, QComboBox {
background: #ffffff;
border: 1px solid #d1d5db;
border-radius: 8px;
padding: 6px 10px;
selection-background-color: rgba(59, 130, 246, 0.20);
}
QLineEdit:hover, QTextEdit:hover, QPlainTextEdit:hover, QComboBox:hover {
border: 1px solid #9ca3af;
}
QLineEdit:focus, QTextEdit:focus, QPlainTextEdit:focus, QComboBox:focus {
border: 1.5px solid #3b82f6;
}
QSpinBox, QDoubleSpinBox {
background: #ffffff;
border: 1px solid #d1d5db;
border-radius: 6px;
padding: 0px;
font-size: 12px;
selection-background-color: rgba(59, 130, 246, 0.20);
}
QSpinBox QLineEdit, QDoubleSpinBox QLineEdit {
padding: 0px 4px;
margin: 0px;
border: none;
background: transparent;
min-height: 20px;
}
QSpinBox:hover, QDoubleSpinBox:hover {
border: 1px solid #9ca3af;
}
QSpinBox:focus, QDoubleSpinBox:focus {
border: 1.5px solid #3b82f6;
}
QAbstractSpinBox::up-button, QAbstractSpinBox::down-button {
width: 16px;
border-left: 1px solid #e5e7eb;
background: #f9fafb;
}
QAbstractSpinBox::up-button:hover, QAbstractSpinBox::down-button:hover {
background: #eef2ff;
}
QComboBox::drop-down {
border: 0;
width: 26px;
}
QComboBox::down-arrow {
image: none;
border-left: 5px solid transparent;
border-right: 5px solid transparent;
border-top: 6px solid #6b7280;
width: 0;
height: 0;
}
QComboBox QAbstractItemView {
background: #ffffff;
border: 1px solid #e5e7eb;
border-radius: 8px;
padding: 4px;
selection-background-color: rgba(59, 130, 246, 0.10);
}
/* ===== 按钮 ===== */
QPushButton, QToolButton {
background: #ffffff;
border: 1px solid #d1d5db;
border-radius: 8px;
padding: 7px 12px;
color: #374151;
}
QPushButton:hover, QToolButton:hover {
background: #f9fafb;
border: 1px solid #9ca3af;
}
QPushButton:pressed, QToolButton:pressed {
background: #f3f4f6;
border: 1px solid #6b7280;
}
QToolButton:checked {
background: rgba(59, 130, 246, 0.10);
border: 1px solid rgba(59, 130, 246, 0.40);
color: #1d4ed8;
}
/* ===== 复选框 ===== */
QCheckBox {
spacing: 8px;
color: #374151;
}
QCheckBox::indicator {
width: 18px;
height: 18px;
border-radius: 5px;
border: 1.5px solid #9ca3af;
background: #ffffff;
}
QCheckBox::indicator:hover {
border: 1.5px solid #3b82f6;
}
QCheckBox::indicator:checked {
background: #3b82f6;
border: 1.5px solid #2563eb;
}
/* ===== 列表/树形视图 ===== */
QListWidget, QTreeView, QTableView {
background: #ffffff;
border: 1px solid #e5e7eb;
border-radius: 10px;
outline: 0;
}
QListWidget::item, QTreeView::item, QTableView::item {
padding: 6px 10px;
}
QListWidget::item:hover, QTreeView::item:hover, QTableView::item:hover {
background: rgba(59, 130, 246, 0.04);
}
QListWidget::item:selected, QTreeView::item:selected, QTableView::item:selected {
background: rgba(59, 130, 246, 0.12);
color: #111827;
}
/* ===== 菜单 ===== */
QMenu {
background: #ffffff;
border: 1px solid #e5e7eb;
border-radius: 12px;
padding: 6px;
}
QMenu::item {
padding: 8px 12px;
border-radius: 6px;
}
QMenu::item:selected {
background: rgba(59, 130, 246, 0.08);
}
QMenu::separator {
height: 1px;
background: #e5e7eb;
margin: 4px 6px;
}
/* ===== 滚动条 ===== */
QScrollBar:vertical {
background: transparent;
width: 10px;
margin: 4px 2px 4px 2px;
}
QScrollBar::handle:vertical {
background: #d1d5db;
border-radius: 5px;
min-height: 32px;
}
QScrollBar::handle:vertical:hover {
background: #9ca3af;
}
QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
height: 0px;
}
QScrollBar::add-page:vertical, QScrollBar::sub-page:vertical {
background: transparent;
}
QScrollBar:horizontal {
background: transparent;
height: 10px;
margin: 2px 4px 2px 4px;
}
QScrollBar::handle:horizontal {
background: #d1d5db;
border-radius: 5px;
min-width: 32px;
}
QScrollBar::handle:horizontal:hover {
background: #9ca3af;
}
QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {
width: 0px;
}
QScrollBar::add-page:horizontal, QScrollBar::sub-page:horizontal {
background: transparent;
}
/* ===== 工具提示 ===== */
QToolTip {
background: #111827;
color: #ffffff;
border: 0;
padding: 8px 10px;
border-radius: 8px;
font-size: 12px;
}
)QSS");
}
} // namespace gui
client/gui/app/AppStyle.h
+11
View File
@@ -0,0 +1,11 @@
#pragma once
#include <QString>
namespace gui {
// 全局 QSS：仅负责外观统一，不承载业务逻辑。
QString appStyleSheet();
} // namespace gui
client/gui/app/main.cpp
+11 -5
View File
@@ -1,16 +1,22 @@
#include "main_window/MainWindow.h"
#include "app/AppStyle.h"
#include "core/image/ImageDecodeConfig.h"
#include "core/large_image/VipsBackend.h"
#include <QApplication>
#include <QImageReader>
#include <QStyleFactory>
int main(int argc, char* argv[]) {
QApplication app(argc, argv);
app.setApplicationName(QStringLiteral("landscape tool"));
app.setStyle(QStyleFactory::create(QStringLiteral("Fusion")));
app.setStyleSheet(gui::appStyleSheet());
// 全局放宽 Qt 图片分配限制（默认常见为 256MB），否则超大分辨率背景/深度可能在任意加载路径被拒绝。
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
QImageReader::setAllocationLimit(1024); // MB
#endif
core::image_decode::prepareLargeImageReader();
const char* av0 = (argc > 0 && argv[0]) ? argv[0] : "landscape_tool";
core::VipsBackend::init(av0);
qAddPostRoutine([]() { core::VipsBackend::shutdown(); });
MainWindow window;
window.show();
client/gui/dialogs/AnimationSchemeSettingsDialog.cpp
+90
View File
@@ -0,0 +1,90 @@
#include "dialogs/AnimationSchemeSettingsDialog.h"
#include "core/domain/Project.h"
#include "core/workspace/ProjectWorkspace.h"
#include <QDialogButtonBox>
#include <QFormLayout>
#include <QLineEdit>
#include <QMessageBox>
#include <QPushButton>
#include <QSpinBox>
#include <QVBoxLayout>
#include <QCheckBox>
AnimationSchemeSettingsDialog::AnimationSchemeSettingsDialog(Mode mode, core::ProjectWorkspace& workspace,
QWidget* parent)
: QDialog(parent)
, m_mode(mode)
, m_workspace(workspace) {
setModal(true);
setMinimumWidth(360);
if (mode == Mode::Create) {
setWindowTitle(QStringLiteral("新建动画方案"));
} else {
setWindowTitle(QStringLiteral("动画方案设置"));
}
auto* root = new QVBoxLayout(this);
root->setContentsMargins(12, 12, 12, 12);
auto* form = new QFormLayout();
form->setSpacing(8);
root->addLayout(form);
m_name = new QLineEdit(this);
m_name->setPlaceholderText(QStringLiteral("显示名称"));
form->addRow(QStringLiteral("名称"), m_name);
m_frames = new QSpinBox(this);
m_frames->setRange(1, 1000000);
m_frames->setValue(600);
form->addRow(QStringLiteral("总帧数"), m_frames);
m_fps = new QSpinBox(this);
m_fps->setRange(1, 240);
m_fps->setValue(std::max(1, m_workspace.project().fps()));
form->addRow(QStringLiteral("帧率"), m_fps);
m_loop = new QCheckBox(QStringLiteral("循环播放"), this);
m_loop->setChecked(true);
form->addRow(QString(), m_loop);
auto* box = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
root->addWidget(box);
connect(box, &QDialogButtonBox::accepted, this, &AnimationSchemeSettingsDialog::accept);
connect(box, &QDialogButtonBox::rejected, this, &QDialog::reject);
}
void AnimationSchemeSettingsDialog::setEditTarget(const QString& animationId) {
m_editId = animationId;
if (const core::Project::Animation* a = m_workspace.project().findAnimationById(animationId)) {
m_name->setText(a->name);
m_frames->setValue(std::max(1, a->lengthFrames));
m_fps->setValue(std::max(1, a->fps));
m_loop->setChecked(a->loop);
}
}
void AnimationSchemeSettingsDialog::accept() {
const QString nm = m_name->text().trimmed();
const int frames = m_frames->value();
const int fps = m_fps->value();
const bool loop = m_loop->isChecked();
if (m_mode == Mode::Create) {
if (!m_workspace.createAnimationScheme(nm, frames, loop, fps, &m_createdNewId)) {
QMessageBox::warning(this, windowTitle(), QStringLiteral("新建失败"));
return;
}
} else {
if (m_editId.isEmpty() || !m_workspace.project().findAnimationById(m_editId)) {
QMessageBox::warning(this, windowTitle(), QStringLiteral("无效的动画方案"));
return;
}
if (!m_workspace.updateAnimationSchemeSettings(m_editId, nm, frames, loop, fps)) {
QMessageBox::warning(this, windowTitle(), QStringLiteral("保存失败"));
return;
}
}
QDialog::accept();
}
client/gui/dialogs/AnimationSchemeSettingsDialog.h
+37
View File
@@ -0,0 +1,37 @@
#pragma once
#include <QDialog>
#include <QString>
namespace core {
class ProjectWorkspace;
}
class QCheckBox;
class QLineEdit;
class QSpinBox;
class AnimationSchemeSettingsDialog final : public QDialog {
Q_OBJECT
public:
enum class Mode { Create, Edit };
AnimationSchemeSettingsDialog(Mode mode, core::ProjectWorkspace& workspace, QWidget* parent = nullptr);
void setEditTarget(const QString& animationId);
QString createdNewId() const { return m_createdNewId; }
private:
void accept() override;
Mode m_mode = Mode::Create;
core::ProjectWorkspace& m_workspace;
QString m_editId;
QString m_createdNewId;
QLineEdit* m_name = nullptr;
QSpinBox* m_frames = nullptr;
QSpinBox* m_fps = nullptr;
QCheckBox* m_loop = nullptr;
};
client/gui/dialogs/BlackholeResolveDialog.cpp
+20 -50
View File
@@ -10,13 +10,13 @@
namespace {
QPushButton* makeAlgoButton(const QString& title, const QString& subtitle, QWidget* parent) {
QPushButton* makeAlgoButton(const QString& title, QWidget* parent) {
auto* btn = new QPushButton(parent);
btn->setCheckable(false);
btn->setCursor(Qt::PointingHandCursor);
btn->setMinimumHeight(86);
btn->setMinimumHeight(48);
btn->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
btn->setText(title + QStringLiteral("\n") + subtitle);
btn->setText(title);
btn->setStyleSheet(
"QPushButton { text-align: left; padding: 10px 12px; border: 1px solid palette(mid); border-radius: 8px; }"
"QPushButton:hover { border-color: palette(highlight); }");
@@ -29,8 +29,8 @@ BlackholeResolveDialog::BlackholeResolveDialog(const QString& blackholeName, QWi
: QDialog(parent),
m_blackholeName(blackholeName) {
setModal(true);
setMinimumSize(560, 420);
setWindowTitle(QStringLiteral("黑洞解决"));
setMinimumSize(400, 320);
setWindowTitle(QStringLiteral("修复 · %1").arg(m_blackholeName));
auto* root = new QVBoxLayout(this);
m_pages = new QStackedWidget(this);
@@ -51,25 +51,13 @@ void BlackholeResolveDialog::buildSelectPage() {
layout->setContentsMargins(8, 8, 8, 8);
layout->setSpacing(12);
auto* title = new QLabel(QStringLiteral("第 1 步：选择黑洞解决算法"), m_pageSelect);
auto* sub = new QLabel(QStringLiteral("当前黑洞：%1").arg(m_blackholeName), m_pageSelect);
title->setStyleSheet("font-size: 18px; font-weight: 600;");
sub->setStyleSheet("color: palette(mid);");
auto* title = new QLabel(QStringLiteral("方式"), m_pageSelect);
title->setStyleSheet("font-size: 16px; font-weight: 600;");
layout->addWidget(title);
layout->addWidget(sub);
auto* btnCopy = makeAlgoButton(
QStringLiteral("复制背景其他区域"),
QStringLiteral("进入画布拖动取样框，直观选择复制来源。"),
m_pageSelect);
auto* btnOriginal = makeAlgoButton(
QStringLiteral("使用原始背景"),
QStringLiteral("撤销黑洞显示，恢复抠图前背景区域。"),
m_pageSelect);
auto* btnModel = makeAlgoButton(
QStringLiteral("模型补全（SDXL Inpaint）"),
QStringLiteral("输入提示词，自动补全缺失区域；可预览后再决定是否接受。"),
m_pageSelect);
auto* btnCopy = makeAlgoButton(QStringLiteral("复制背景"), m_pageSelect);
auto* btnOriginal = makeAlgoButton(QStringLiteral("原始背景"), m_pageSelect);
auto* btnModel = makeAlgoButton(QStringLiteral("模型补全"), m_pageSelect);
layout->addWidget(btnCopy);
layout->addWidget(btnOriginal);
layout->addWidget(btnModel);
@@ -100,12 +88,8 @@ void BlackholeResolveDialog::buildDetailPage() {
layout->setSpacing(10);
m_detailTitle = new QLabel(m_pageDetail);
m_detailTitle->setStyleSheet("font-size: 18px; font-weight: 600;");
m_detailHint = new QLabel(m_pageDetail);
m_detailHint->setWordWrap(true);
m_detailHint->setStyleSheet("color: palette(mid);");
m_detailTitle->setStyleSheet("font-size: 15px; font-weight: 600;");
layout->addWidget(m_detailTitle);
layout->addWidget(m_detailHint);
m_algoDetails = new QStackedWidget(m_pageDetail);
@@ -120,10 +104,7 @@ void BlackholeResolveDialog::buildDetailPage() {
auto* pLay = new QVBoxLayout(panel);
pLay->setSpacing(8);
auto* tip = new QLabel(
QStringLiteral("说明：点击“应用”后进入画布拖动模式。\n在画布中拖动青色取样框，松开鼠标即可将该区域复制到黑洞位置并自动移除黑洞。"),
panel);
tip->setWordWrap(true);
auto* tip = new QLabel(QStringLiteral("应用后在画布拖取样框。"), panel);
tip->setStyleSheet("color: palette(mid);");
pLay->addWidget(tip);
cLay->addWidget(panel);
@@ -135,17 +116,9 @@ void BlackholeResolveDialog::buildDetailPage() {
{
auto* oLay = new QVBoxLayout(m_originalDetail);
oLay->setSpacing(8);
auto* desc = new QLabel(
QStringLiteral("该方案不会改动背景像素文件，只会将黑洞切换为不显示，从而恢复原始背景区域。"),
m_originalDetail);
auto* desc = new QLabel(QStringLiteral("仅隐藏黑洞，不改动背景文件。"), m_originalDetail);
desc->setWordWrap(true);
auto* note = new QLabel(
QStringLiteral("适用场景：当前黑洞区域无需二次修补，只需恢复抠图前背景；应用后黑洞会自动移除。"),
m_originalDetail);
note->setWordWrap(true);
note->setStyleSheet("color: palette(mid);");
oLay->addWidget(desc);
oLay->addWidget(note);
oLay->addStretch(1);
}
@@ -161,8 +134,8 @@ void BlackholeResolveDialog::buildDetailPage() {
pLay->setSpacing(8);
m_promptEdit = new QPlainTextEdit(panel);
m_promptEdit->setPlainText(QStringLiteral("This is part of a Chinese painting; please complete the background for me, following the style of the other parts."));
m_promptEdit->setMinimumHeight(90);
m_promptEdit->setPlaceholderText(QStringLiteral("提示词（可选）"));
m_promptEdit->setMinimumHeight(72);
pLay->addWidget(m_promptEdit);
mLay->addWidget(panel);
@@ -175,8 +148,8 @@ void BlackholeResolveDialog::buildDetailPage() {
layout->addWidget(m_algoDetails, 1);
auto* btns = new QDialogButtonBox(m_pageDetail);
auto* btnBack = btns->addButton(QStringLiteral("上一步"), QDialogButtonBox::ActionRole);
auto* btnApply = btns->addButton(QStringLiteral("应用"), QDialogButtonBox::AcceptRole);
auto* btnBack = btns->addButton(QStringLiteral("返回"), QDialogButtonBox::ActionRole);
auto* btnApply = btns->addButton(QStringLiteral("确定"), QDialogButtonBox::AcceptRole);
auto* btnCancel = btns->addButton(QDialogButtonBox::Cancel);
connect(btnBack, &QPushButton::clicked, this, [this]() {
m_pages->setCurrentWidget(m_pageSelect);
@@ -191,16 +164,13 @@ void BlackholeResolveDialog::buildDetailPage() {
void BlackholeResolveDialog::enterAlgorithmPage(Algorithm algo) {
m_selectedAlgorithm = algo;
if (algo == Algorithm::CopyBackgroundRegion) {
m_detailTitle->setText(QStringLiteral("第 2 步：复制背景其他区域"));
m_detailHint->setText(QStringLiteral("准备进入画布拖动取样框模式。"));
m_detailTitle->setText(QStringLiteral("复制背景"));
m_algoDetails->setCurrentWidget(m_copyDetail);
} else if (algo == Algorithm::UseOriginalBackground) {
m_detailTitle->setText(QStringLiteral("第 2 步：使用原始背景"));
m_detailHint->setText(QStringLiteral("确认后将切换为原始背景显示。"));
m_detailTitle->setText(QStringLiteral("原始背景"));
m_algoDetails->setCurrentWidget(m_originalDetail);
} else {
m_detailTitle->setText(QStringLiteral("第 2 步：模型补全（SDXL Inpaint）"));
m_detailHint->setText(QStringLiteral("输入提示词（可选），点击应用后将生成预览。"));
m_detailTitle->setText(QStringLiteral("模型补全"));
m_algoDetails->setCurrentWidget(m_modelDetail);
}
m_pages->setCurrentWidget(m_pageDetail);
client/gui/dialogs/BlackholeResolveDialog.h
-1
View File
@@ -34,7 +34,6 @@ private:
QWidget* m_pageDetail = nullptr;
QLabel* m_detailTitle = nullptr;
QLabel* m_detailHint = nullptr;
QStackedWidget* m_algoDetails = nullptr;
QWidget* m_copyDetail = nullptr;
client/gui/dialogs/EntityFinalizeDialog.cpp
+3 -2
View File
@@ -1,9 +1,10 @@
#include "dialogs/EntityFinalizeDialog.h"
#include "widgets/CompactNumericSpinBox.h"
#include <QDialogButtonBox>
#include <QFormLayout>
#include <QLineEdit>
#include <QDoubleSpinBox>
#include <QVBoxLayout>
EntityFinalizeDialog::EntityFinalizeDialog(QWidget* parent)
@@ -18,7 +19,7 @@ EntityFinalizeDialog::EntityFinalizeDialog(QWidget* parent)
m_name->setPlaceholderText(QStringLiteral("例如：entity-1、人物、树、建筑…"));
form->addRow(QStringLiteral("名称"), m_name);
m_userScale = new QDoubleSpinBox(this);
m_userScale = new gui::CompactDoubleSpinBox(this);
m_userScale->setDecimals(3);
m_userScale->setRange(0.01, 50.0);
m_userScale->setSingleStep(0.05);
client/gui/dialogs/EntityIntroPopup.cpp
+5 -1
View File
@@ -1,5 +1,8 @@
#include "dialogs/EntityIntroPopup.h"
#include "core/image/ImageDecodeConfig.h"
#include "core/image/ImageFileLoader.h"
#include <QDir>
#include <QFileInfo>
#include <QGuiApplication>
@@ -95,7 +98,8 @@ void EntityIntroPopup::setContent(const core::EntityIntroContent& content) {
auto* lab = new QLabel(m_imagesHost);
lab->setAlignment(Qt::AlignCenter);
if (!abs.isEmpty() && QFileInfo::exists(abs)) {
QPixmap pm(abs);
QPixmap pm = QPixmap::fromImage(
core::image_file::loadImageLimited(abs, core::image_decode::kPreviewMaxPixels));
if (!pm.isNull()) {
if (pm.width() > kMaxThumb || pm.height() > kMaxThumb) {
pm = pm.scaled(kMaxThumb, kMaxThumb, Qt::KeepAspectRatio, Qt::SmoothTransformation);
client/gui/dialogs/FrameAnimationDialog.cpp
+358 -53
View File
@@ -1,29 +1,45 @@
#include "dialogs/FrameAnimationDialog.h"
#include "core/animation/AnimationSampling.h"
#include "core/image/ImageDecodeConfig.h"
#include "core/image/ImageFileLoader.h"
#include "core/net/ModelServerClient.h"
#include "core/workspace/ProjectWorkspace.h"
#include "dialogs/CancelableTaskDialog.h"
#include <QBoxLayout>
#include <QAbstractItemView>
#include <QBuffer>
#include <QColor>
#include <QColorDialog>
#include <QDialog>
#include <QDialogButtonBox>
#include <QDir>
#include <QFormLayout>
#include <QFileDialog>
#include <QFileInfo>
#include <QImage>
#include <QImageReader>
#include <QIODevice>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QLabel>
#include <QLineEdit>
#include <QListWidget>
#include <QMessageBox>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QPixmap>
#include <QPushButton>
#include <QUrl>
namespace {
QString resolvedImageAbsForFrame(const core::ProjectWorkspace& ws,
const core::Project::Entity& e,
int frame) {
const QString rel = core::sampleImagePath(e.imageFrames, frame, e.imagePath);
if (rel.isEmpty()) return {};
const QString abs = QDir(ws.projectDir()).filePath(rel);
return abs;
const QByteArray png = ws.entityImagePngAt(e.id, frame);
if (png.isEmpty()) return {};
return QStringLiteral("pngb64:") + QString::fromLatin1(png.toBase64());
}
} // namespace
@@ -56,6 +72,7 @@ FrameAnimationDialog::FrameAnimationDialog(core::ProjectWorkspace& workspace,
m_list = new QListWidget(this);
m_list->setMinimumWidth(240);
m_list->setSelectionMode(QAbstractItemView::ExtendedSelection);
mid->addWidget(m_list, 0);
auto* right = new QVBoxLayout();
@@ -71,18 +88,27 @@ FrameAnimationDialog::FrameAnimationDialog(core::ProjectWorkspace& workspace,
auto* row = new QHBoxLayout();
right->addLayout(row);
m_btnReplace = new QPushButton(QStringLiteral("替换此帧…"), this);
m_btnClear = new QPushButton(QStringLiteral("清除此帧（恢复默认）"), this);
m_btnClear = new QPushButton(QStringLiteral("清除选中帧"), this);
row->addWidget(m_btnReplace);
row->addWidget(m_btnClear);
auto* row2 = new QHBoxLayout();
right->addLayout(row2);
m_btnImportFiles = new QPushButton(QStringLiteral("批量导入（多选图片）…"), this);
m_btnImportFolder = new QPushButton(QStringLiteral("批量导入（文件夹）…"), this);
m_btnImportFiles = new QPushButton(QStringLiteral("导入图片…"), this);
m_btnImportFolder = new QPushButton(QStringLiteral("导入文件夹…"), this);
row2->addWidget(m_btnImportFiles);
row2->addWidget(m_btnImportFolder);
row2->addStretch(1);
auto* row3 = new QHBoxLayout();
right->addLayout(row3);
m_btnAiGenerate = new QPushButton(QStringLiteral("AI 生成逐帧动画…"), this);
row3->addWidget(m_btnAiGenerate);
auto* aiHint = new QLabel(QStringLiteral("写入选中区间"), this);
aiHint->setStyleSheet(QStringLiteral("color: #777;"));
row3->addWidget(aiHint);
row3->addStretch(1);
auto* closeRow = new QHBoxLayout();
root->addLayout(closeRow);
closeRow->addStretch(1);
@@ -95,6 +121,7 @@ FrameAnimationDialog::FrameAnimationDialog(core::ProjectWorkspace& workspace,
connect(m_btnClear, &QPushButton::clicked, this, &FrameAnimationDialog::onClearCurrentFrame);
connect(m_btnImportFiles, &QPushButton::clicked, this, &FrameAnimationDialog::onBatchImportFiles);
connect(m_btnImportFolder, &QPushButton::clicked, this, &FrameAnimationDialog::onBatchImportFolder);
connect(m_btnAiGenerate, &QPushButton::clicked, this, &FrameAnimationDialog::onGenerateAiFrames);
rebuildFrameList();
if (m_list->count() > 0) {
@@ -118,16 +145,11 @@ void FrameAnimationDialog::rebuildFrameList() {
// 默认贴图（用于 UI 提示）
m_defaultImageAbs.clear();
if (!hit->imagePath.isEmpty()) {
const QString abs = QDir(m_workspace.projectDir()).filePath(hit->imagePath);
if (QFileInfo::exists(abs)) {
m_defaultImageAbs = abs;
}
}
for (int f = m_start; f <= m_end; ++f) {
bool hasCustom = false;
for (const auto& k : hit->imageFrames) {
const auto spriteFrames = m_workspace.entitySpriteFrames(m_entityId);
for (const auto& k : spriteFrames) {
if (k.frame == f) {
hasCustom = true;
break;
@@ -159,38 +181,33 @@ void FrameAnimationDialog::updatePreviewForFrame(int frame) {
if (!hit) return;
const QString abs = resolvedImageAbsForFrame(m_workspace, *hit, frame);
if (abs.isEmpty() || !QFileInfo::exists(abs)) {
if (abs.isEmpty()) {
m_preview->setText(QStringLiteral("无图像"));
return;
}
QPixmap pm(abs);
if (pm.isNull()) {
QImage loaded;
if (abs.startsWith(QStringLiteral("pngb64:"))) {
const QByteArray b64 = abs.mid(QStringLiteral("pngb64:").size()).toLatin1();
const QByteArray raw = QByteArray::fromBase64(b64);
loaded.loadFromData(raw, "PNG");
} else {
if (!QFileInfo::exists(abs)) {
m_preview->setText(QStringLiteral("无图像"));
return;
}
loaded = core::image_file::loadImageLimited(abs, core::image_decode::kPreviewMaxPixels);
}
if (loaded.isNull()) {
m_preview->setText(QStringLiteral("加载失败"));
return;
}
QPixmap pm = QPixmap::fromImage(loaded);
m_preview->setPixmap(pm.scaled(m_preview->size(), Qt::KeepAspectRatio, Qt::SmoothTransformation));
}
bool FrameAnimationDialog::applyImageToFrame(int frame, const QString& absImagePath) {
// Qt 默认的 image allocation limit 较小，超大分辨率图可能会被拒绝。
// 这里提高 limit，并对极端大图按像素数上限自动缩放，避免 OOM。
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
QImageReader::setAllocationLimit(1024); // MB
#endif
QImageReader reader(absImagePath);
reader.setAutoTransform(true);
const QSize sz = reader.size();
if (sz.isValid()) {
constexpr qint64 kMaxPixels = 120LL * 1000LL * 1000LL; // 120MP
const qint64 pixels = qint64(sz.width()) * qint64(sz.height());
if (pixels > kMaxPixels) {
const double s = std::sqrt(double(kMaxPixels) / std::max<double>(1.0, double(pixels)));
const int nw = std::max(1, int(std::lround(sz.width() * s)));
const int nh = std::max(1, int(std::lround(sz.height() * s)));
reader.setScaledSize(QSize(nw, nh));
}
}
QImage img = reader.read();
QImage img =
core::image_file::loadImageLimited(absImagePath, core::image_decode::kWorkspaceMaxPixels);
if (img.isNull()) {
return false;
}
@@ -200,6 +217,93 @@ bool FrameAnimationDialog::applyImageToFrame(int frame, const QString& absImageP
return m_workspace.setEntityImageFrame(m_entityId, frame, img);
}
QVector<int> FrameAnimationDialog::targetFramesForWrite(int requestedCount) const {
QVector<int> frames;
if (m_list) {
const auto selected = m_list->selectedItems();
frames.reserve(selected.size());
for (auto* it : selected) {
if (it) frames.push_back(it->data(Qt::UserRole).toInt());
}
std::sort(frames.begin(), frames.end());
frames.erase(std::unique(frames.begin(), frames.end()), frames.end());
}
if (!frames.isEmpty()) {
if (requestedCount > 0 && frames.size() > requestedCount) {
frames.resize(requestedCount);
}
return frames;
}
const int count = requestedCount > 0 ? std::min(requestedCount, m_end - m_start + 1)
: (m_end - m_start + 1);
frames.reserve(count);
for (int i = 0; i < count; ++i) {
frames.push_back(m_start + i);
}
return frames;
}
QByteArray FrameAnimationDialog::currentEntityPngBytes(QString* outError) const {
if (outError) outError->clear();
if (!m_workspace.isOpen()) {
if (outError) *outError = QStringLiteral("未打开项目。");
return {};
}
const auto& ents = m_workspace.entities();
const core::Project::Entity* hit = nullptr;
for (const auto& e : ents) {
if (e.id == m_entityId) {
hit = &e;
break;
}
}
if (!hit) {
if (outError) *outError = QStringLiteral("未找到当前实体。");
return {};
}
int sourceFrame = m_start;
if (m_list && m_list->currentItem()) {
sourceFrame = m_list->currentItem()->data(Qt::UserRole).toInt();
}
const QString abs = resolvedImageAbsForFrame(m_workspace, *hit, sourceFrame);
if (abs.isEmpty()) {
if (outError) *outError = QStringLiteral("当前实体没有可用的角色贴图。");
return {};
}
QImage img;
if (abs.startsWith(QStringLiteral("pngb64:"))) {
const QByteArray b64 = abs.mid(QStringLiteral("pngb64:").size()).toLatin1();
const QByteArray raw = QByteArray::fromBase64(b64);
img.loadFromData(raw, "PNG");
} else {
if (!QFileInfo::exists(abs)) {
if (outError) *outError = QStringLiteral("当前实体没有可用的角色贴图。");
return {};
}
img = core::image_file::loadImageLimited(abs, core::image_decode::kWorkspaceMaxPixels);
}
if (img.isNull()) {
if (outError) *outError = QStringLiteral("角色贴图读取失败。");
return {};
}
if (img.format() != QImage::Format_ARGB32 && img.format() != QImage::Format_ARGB32_Premultiplied) {
img = img.convertToFormat(QImage::Format_ARGB32);
}
QByteArray png;
QBuffer buf(&png);
if (!buf.open(QIODevice::WriteOnly) || !img.save(&buf, "PNG")) {
if (outError) *outError = QStringLiteral("角色贴图编码 PNG 失败。");
return {};
}
return png;
}
void FrameAnimationDialog::onReplaceCurrentFrame() {
auto* it = m_list->currentItem();
if (!it) return;
@@ -222,15 +326,17 @@ void FrameAnimationDialog::onReplaceCurrentFrame() {
}
if (hit) {
// 是否已有精确关键帧
for (const auto& k : hit->imageFrames) {
const auto spriteFrames = m_workspace.entitySpriteFrames(m_entityId);
for (const auto& k : spriteFrames) {
if (k.frame == f + 1) {
hasExplicitKeyAtFPlus1 = true;
}
}
prevRelPathForF = core::sampleImagePath(hit->imageFrames, f, hit->imagePath);
prevRelPathForFPlus1 = core::sampleImagePath(hit->imageFrames, f + 1, hit->imagePath);
prevRelPathForF = m_workspace.entityImagePathAt(m_entityId, f);
prevRelPathForFPlus1 = m_workspace.entityImagePathAt(m_entityId, f + 1);
}
}
(void)prevRelPathForF;
const QString path = QFileDialog::getOpenFileName(
this,
@@ -255,14 +361,12 @@ void FrameAnimationDialog::onReplaceCurrentFrame() {
}
void FrameAnimationDialog::onClearCurrentFrame() {
auto* it = m_list->currentItem();
if (!it) return;
const int f = it->data(Qt::UserRole).toInt();
if (!m_workspace.removeEntityImageFrame(m_entityId, f)) {
return;
const QVector<int> frames = targetFramesForWrite(0);
for (int f : frames) {
m_workspace.removeEntityImageFrame(m_entityId, f);
}
rebuildFrameList();
updatePreviewForFrame(f);
onSelectFrame();
}
void FrameAnimationDialog::onBatchImportFiles() {
@@ -274,10 +378,10 @@ void FrameAnimationDialog::onBatchImportFiles() {
if (paths.isEmpty()) return;
QStringList sorted = paths;
sorted.sort(Qt::CaseInsensitive);
const int need = m_end - m_start + 1;
const int count = std::min(need, static_cast<int>(sorted.size()));
const QVector<int> targets = targetFramesForWrite(static_cast<int>(sorted.size()));
const int count = std::min(static_cast<int>(targets.size()), static_cast<int>(sorted.size()));
for (int i = 0; i < count; ++i) {
applyImageToFrame(m_start + i, sorted[i]);
applyImageToFrame(targets[i], sorted[i]);
}
rebuildFrameList();
onSelectFrame();
@@ -296,12 +400,213 @@ void FrameAnimationDialog::onBatchImportFolder() {
QStringLiteral("*.webp")};
const QStringList files = d.entryList(filters, QDir::Files, QDir::Name);
if (files.isEmpty()) return;
const int need = m_end - m_start + 1;
const int count = std::min(need, static_cast<int>(files.size()));
const QVector<int> targets = targetFramesForWrite(static_cast<int>(files.size()));
const int count = std::min(static_cast<int>(targets.size()), static_cast<int>(files.size()));
for (int i = 0; i < count; ++i) {
applyImageToFrame(m_start + i, d.filePath(files[i]));
applyImageToFrame(targets[i], d.filePath(files[i]));
}
rebuildFrameList();
onSelectFrame();
}
void FrameAnimationDialog::onGenerateAiFrames() {
const QVector<int> targetFrames = targetFramesForWrite(0);
const int frameCount = static_cast<int>(targetFrames.size());
if (frameCount <= 0) {
QMessageBox::warning(this, QStringLiteral("AI 生成动画"), QStringLiteral("当前区间无有效帧。"));
return;
}
QString imageErr;
const QByteArray characterPng = currentEntityPngBytes(&imageErr);
if (characterPng.isEmpty()) {
QMessageBox::warning(this,
QStringLiteral("AI 生成动画"),
imageErr.isEmpty() ? QStringLiteral("无法读取当前实体贴图。") : imageErr);
return;
}
QDialog cfg(this);
cfg.setWindowTitle(QStringLiteral("AI 生成实体动画"));
cfg.setModal(true);
auto* root = new QVBoxLayout(&cfg);
root->setContentsMargins(14, 14, 14, 14);
root->setSpacing(10);
auto* form = new QFormLayout();
root->addLayout(form);
auto* promptEdit = new QLineEdit(QStringLiteral("walk cycle"), &cfg);
form->addRow(QStringLiteral("动画提示词"), promptEdit);
auto* bgRow = new QWidget(&cfg);
auto* bgLayout = new QHBoxLayout(bgRow);
bgLayout->setContentsMargins(0, 0, 0, 0);
auto* bgEdit = new QLineEdit(QStringLiteral("#00FF00"), bgRow);
auto* bgBtn = new QPushButton(QStringLiteral("选择…"), bgRow);
bgLayout->addWidget(bgEdit, 1);
bgLayout->addWidget(bgBtn);
form->addRow(QStringLiteral("生成背景色"), bgRow);
auto* frameLabel = new QLabel(QString::number(frameCount), &cfg);
form->addRow(QStringLiteral("帧数"), frameLabel);
auto* buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &cfg);
buttons->button(QDialogButtonBox::Ok)->setText(QStringLiteral("开始生成"));
buttons->button(QDialogButtonBox::Cancel)->setText(QStringLiteral("取消"));
root->addWidget(buttons);
connect(bgBtn, &QPushButton::clicked, &cfg, [bgEdit, &cfg]() {
const QColor initial(bgEdit->text().trimmed());
const QColor c = QColorDialog::getColor(initial.isValid() ? initial : QColor(0, 255, 0),
&cfg,
QStringLiteral("选择纯色背景"));
if (c.isValid()) {
bgEdit->setText(c.name(QColor::HexRgb).toUpper());
}
});
connect(buttons, &QDialogButtonBox::accepted, &cfg, &QDialog::accept);
connect(buttons, &QDialogButtonBox::rejected, &cfg, &QDialog::reject);
if (cfg.exec() != QDialog::Accepted) {
return;
}
const QString prompt = promptEdit->text().trimmed();
if (prompt.isEmpty()) {
QMessageBox::warning(this, QStringLiteral("AI 生成动画"), QStringLiteral("动画提示词不能为空。"));
return;
}
QString base;
const QByteArray env = qgetenv("MODEL_SERVER_URL");
base = env.isEmpty() ? QStringLiteral("http://127.0.0.1:8000") : QString::fromUtf8(env);
auto* client = new core::ModelServerClient(this);
client->setBaseUrl(QUrl(base));
QString immediateErr;
QNetworkReply* reply = client->animateCharacterSequenceAsync(
characterPng,
prompt,
QStringLiteral("blur, distortion, extra limbs, bad hands, text, watermark"),
bgEdit->text(),
40,
frameCount,
25,
8.0,
768,
-1,
&immediateErr);
if (!reply) {
QMessageBox::warning(this,
QStringLiteral("AI 生成动画"),
immediateErr.isEmpty() ? QStringLiteral("无法发起后端请求。") : immediateErr);
client->deleteLater();
return;
}
auto* task = new CancelableTaskDialog(
QStringLiteral("AI 生成实体动画"),
QStringLiteral("正在生成 PNG 序列。该过程可能耗时较久，请稍候……"),
this);
task->setAttribute(Qt::WA_DeleteOnClose, true);
connect(task, &CancelableTaskDialog::canceled, this, [reply, task]() {
if (reply) reply->abort();
if (task) task->reject();
});
connect(reply, &QNetworkReply::finished, this, [this, reply, task, client, frameCount, targetFrames]() {
const int httpStatus = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
const QByteArray raw = reply->readAll();
const auto netErr = reply->error();
const QString netErrStr = reply->errorString();
reply->deleteLater();
client->deleteLater();
if (task) task->close();
if (netErr != QNetworkReply::NoError) {
QMessageBox::warning(this,
QStringLiteral("AI 生成动画"),
QStringLiteral("网络错误：%1").arg(netErrStr));
return;
}
if (httpStatus != 200) {
QString detail;
const QJsonDocument jerr = QJsonDocument::fromJson(raw);
if (jerr.isObject()) {
detail = jerr.object().value(QStringLiteral("detail")).toString();
}
QMessageBox::warning(this,
QStringLiteral("AI 生成动画"),
detail.isEmpty() ? QStringLiteral("后端返回 HTTP %1。").arg(httpStatus)
: QStringLiteral("后端错误（HTTP %1）：%2").arg(httpStatus).arg(detail));
return;
}
const QJsonDocument jd = QJsonDocument::fromJson(raw);
if (!jd.isObject()) {
QMessageBox::warning(this, QStringLiteral("AI 生成动画"), QStringLiteral("响应不是 JSON。"));
return;
}
const QJsonObject obj = jd.object();
if (!obj.value(QStringLiteral("success")).toBool()) {
const QString err = obj.value(QStringLiteral("error")).toString();
QMessageBox::warning(this,
QStringLiteral("AI 生成动画"),
err.isEmpty() ? QStringLiteral("生成失败。") : err);
return;
}
const QJsonArray frames = obj.value(QStringLiteral("frames")).toArray();
if (frames.isEmpty()) {
QMessageBox::warning(this, QStringLiteral("AI 生成动画"), QStringLiteral("后端未返回 PNG 帧。"));
return;
}
int applied = 0;
const int count = std::min(frameCount, static_cast<int>(frames.size()));
for (int i = 0; i < count; ++i) {
const QJsonObject fobj = frames.at(i).toObject();
const QString b64 = fobj.value(QStringLiteral("image_b64")).toString();
if (b64.isEmpty()) {
continue;
}
QImage img;
img.loadFromData(QByteArray::fromBase64(b64.toLatin1()), "PNG");
if (img.isNull()) {
continue;
}
if (img.format() != QImage::Format_ARGB32_Premultiplied) {
img = img.convertToFormat(QImage::Format_ARGB32_Premultiplied);
}
if (i < targetFrames.size() && m_workspace.setEntityImageFrame(m_entityId, targetFrames[i], img)) {
++applied;
}
}
rebuildFrameList();
if (m_list && m_list->count() > 0) {
m_list->setCurrentRow(0);
}
onSelectFrame();
if (applied <= 0) {
QMessageBox::warning(this, QStringLiteral("AI 生成动画"), QStringLiteral("生成成功，但写入项目失败。"));
return;
}
if (applied < frameCount) {
QMessageBox::information(this,
QStringLiteral("AI 生成动画"),
QStringLiteral("已写入 %1/%2 帧；部分帧解析或保存失败。").arg(applied).arg(frameCount));
} else {
QMessageBox::information(this,
QStringLiteral("AI 生成动画"),
QStringLiteral("已写入 %1 帧。").arg(applied));
}
});
task->show();
}
client/gui/dialogs/FrameAnimationDialog.h
+5
View File
@@ -3,6 +3,7 @@
#include <QDialog>
#include <QString>
#include <QStringList>
#include <QVector>
namespace core {
class ProjectWorkspace;
@@ -27,11 +28,14 @@ private slots:
void onClearCurrentFrame();
void onBatchImportFiles();
void onBatchImportFolder();
void onGenerateAiFrames();
private:
void rebuildFrameList();
void updatePreviewForFrame(int frame);
bool applyImageToFrame(int frame, const QString& absImagePath);
QVector<int> targetFramesForWrite(int requestedCount) const;
QByteArray currentEntityPngBytes(QString* outError) const;
private:
core::ProjectWorkspace& m_workspace;
@@ -46,6 +50,7 @@ private:
QPushButton* m_btnClear = nullptr;
QPushButton* m_btnImportFiles = nullptr;
QPushButton* m_btnImportFolder = nullptr;
QPushButton* m_btnAiGenerate = nullptr;
QString m_defaultImageAbs;
};
client/gui/dialogs/ImageCropDialog.cpp
+431 -93
View File
@@ -1,64 +1,122 @@
#include "dialogs/ImageCropDialog.h"
#include "core/image/ImageDecodeConfig.h"
#include "core/image/ImageFileLoader.h"
#include <QBoxLayout>
#include <QCursor>
#include <QDialogButtonBox>
#include <QLabel>
#include <QMouseEvent>
#include <QPainter>
#include <QPushButton>
#include <QImageReader>
#include <QResizeEvent>
#include <QWheelEvent>
#include <QtMath>
#include <algorithm>
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
# define CROP_LOCAL_POS_M(E) (E)->position()
# define CROP_LOCAL_POS_W(E) (E)->position()
#else
# define CROP_LOCAL_POS_M(E) (E)->localPos()
# define CROP_LOCAL_POS_W(E) (E)->posF()
#endif
namespace {
constexpr int kMinCropSidePx = 2;
/// 相对「适应窗口」倍率的乘子；范围极大以便实质任意缩放（仍避免数值溢出）
constexpr qreal kZoomMulMin = 1e-12;
constexpr qreal kZoomMulMax = 1e12;
constexpr qreal kHandleViewPx = 7.0;
enum class HitPart : quint8 {
None,
Inside,
N,
Ne,
E,
Se,
S,
Sw,
W,
Nw,
/// 平移视图（选区外左键拖动）
PanView
};
QRect clampRectToBounds(QRect r, const QRect& bounds) {
r = r.normalized();
if (r.width() < kMinCropSidePx || r.height() < kMinCropSidePx) {
return {};
}
if (r.left() < bounds.left()) {
r.moveLeft(bounds.left());
}
if (r.top() < bounds.top()) {
r.moveTop(bounds.top());
}
if (r.right() > bounds.right()) {
r.moveRight(bounds.right());
}
if (r.bottom() > bounds.bottom()) {
r.moveBottom(bounds.bottom());
}
if (r.width() < kMinCropSidePx || r.height() < kMinCropSidePx) {
return {};
}
return r;
}
} // namespace
class ImageCropDialog::CropView final : public QWidget {
public:
explicit CropView(QWidget* parent = nullptr)
: QWidget(parent) {
setMouseTracking(true);
setFocusPolicy(Qt::WheelFocus);
setMinimumSize(480, 320);
}
void setImage(const QImage& img) {
m_image = img;
m_selection = {};
m_zoom = 1.0;
m_pan = QPointF();
m_selImage = m_image.isNull() ? QRect() : QRect(QPoint(0, 0), m_image.size());
m_dragPart = HitPart::None;
updateGeometry();
update();
}
bool hasSelection() const { return !m_selection.isNull() && m_selection.width() > 0 && m_selection.height() > 0; }
bool hasSelection() const {
return !m_image.isNull() && m_selImage.width() >= kMinCropSidePx && m_selImage.height() >= kMinCropSidePx;
}
QRect selectionInImagePixels() const {
if (m_image.isNull() || !hasSelection()) {
return {};
}
const auto map = viewToImageTransform();
// selection 是 view 坐标；映射到 image 像素坐标
const QRectF selF = QRectF(m_selection).normalized();
bool invertible = false;
const QTransform inv = map.inverted(&invertible);
if (!invertible) {
return {};
}
const QPointF topLeftImg = inv.map(selF.topLeft());
const QPointF bottomRightImg = inv.map(selF.bottomRight());
// 使用 floor/ceil，避免因为取整导致宽高变 0
const int left = qFloor(std::min(topLeftImg.x(), bottomRightImg.x()));
const int top = qFloor(std::min(topLeftImg.y(), bottomRightImg.y()));
const int right = qCeil(std::max(topLeftImg.x(), bottomRightImg.x()));
const int bottom = qCeil(std::max(topLeftImg.y(), bottomRightImg.y()));
QRect r(QPoint(left, top), QPoint(right, bottom));
r = r.normalized().intersected(QRect(0, 0, m_image.width(), m_image.height()));
return r;
return m_selImage.normalized().intersected(QRect(0, 0, m_image.width(), m_image.height()));
}
void resetSelection() {
m_selection = {};
if (!m_image.isNull()) {
m_selImage = QRect(QPoint(0, 0), m_image.size());
} else {
m_selImage = {};
}
update();
}
protected:
void resizeEvent(QResizeEvent* e) override {
QWidget::resizeEvent(e);
update();
}
void paintEvent(QPaintEvent*) override {
QPainter p(this);
p.fillRect(rect(), palette().window());
@@ -69,84 +127,362 @@ protected:
return;
}
const auto map = viewToImageTransform();
qreal eff = 0;
QPointF tl;
computeLayout(eff, tl);
const QTransform imgToView = imageToViewTransform(eff, tl);
p.setRenderHint(QPainter::SmoothPixmapTransform, true);
p.setTransform(map);
p.setTransform(imgToView);
p.drawImage(QPoint(0, 0), m_image);
p.resetTransform();
if (hasSelection()) {
// 避免 CompositionMode_Clear 在某些平台/样式下表现异常：
// 用“围绕选区画四块遮罩”的方式实现高亮裁剪区域。
const QRect sel = m_selection.normalized().intersected(rect());
const QColor shade(0, 0, 0, 120);
const QRectF selView = imgToView.mapRect(QRectF(m_selImage));
const QRect sel = selView.toAlignedRect().intersected(rect());
// 上
p.fillRect(QRect(0, 0, width(), sel.top()), shade);
// 下
p.fillRect(QRect(0, sel.bottom(), width(), height() - sel.bottom()), shade);
// 左
p.fillRect(QRect(0, sel.top(), sel.left(), sel.height()), shade);
// 右
p.fillRect(QRect(sel.right(), sel.top(), width() - sel.right(), sel.height()), shade);
const QColor shade(0, 0, 0, 120);
p.fillRect(QRect(0, 0, width(), sel.top()), shade);
p.fillRect(QRect(0, sel.bottom(), width(), height() - sel.bottom()), shade);
p.fillRect(QRect(0, sel.top(), sel.left(), sel.height()), shade);
p.fillRect(QRect(sel.right(), sel.top(), width() - sel.right(), sel.height()), shade);
p.setPen(QPen(QColor(255, 255, 255, 220), 2));
p.drawRect(sel);
p.setPen(QPen(QColor(255, 255, 255, 230), 2));
p.setBrush(Qt::NoBrush);
p.drawRect(sel);
const qreal hsz = kHandleViewPx;
const QPointF c[4] = {
selView.topLeft(),
selView.topRight(),
selView.bottomRight(),
selView.bottomLeft(),
};
p.setPen(QPen(QColor(255, 255, 255, 240), 1));
p.setBrush(QColor(255, 255, 255, 220));
for (const QPointF& pt : c) {
p.drawRect(QRectF(pt.x() - hsz * 0.5, pt.y() - hsz * 0.5, hsz, hsz));
}
}
void wheelEvent(QWheelEvent* e) override {
if (m_image.isNull()) {
e->ignore();
return;
}
qreal effOld = 0;
QPointF tlOld;
computeLayout(effOld, tlOld);
const QPointF cursor = CROP_LOCAL_POS_W(e);
const QPointF imgPt((cursor.x() - tlOld.x()) / effOld, (cursor.y() - tlOld.y()) / effOld);
const qreal steps = e->angleDelta().y() / 120.0;
const qreal factor = std::pow(1.1, steps);
const qreal newZoom = std::clamp(m_zoom * factor, kZoomMulMin, kZoomMulMax);
if (qFuzzyCompare(newZoom, m_zoom)) {
e->accept();
return;
}
m_zoom = newZoom;
qreal effNew = 0;
QPointF tlIgnored;
computeLayout(effNew, tlIgnored);
const QPointF tlNew(cursor.x() - imgPt.x() * effNew, cursor.y() - imgPt.y() * effNew);
const qreal iw = m_image.width();
const qreal ih = m_image.height();
const qreal vw = width();
const qreal vh = height();
const QPointF centerOff((vw - iw * effNew) / 2.0, (vh - ih * effNew) / 2.0);
m_pan = tlNew - centerOff;
e->accept();
update();
}
void mousePressEvent(QMouseEvent* e) override {
if (m_image.isNull() || e->button() != Qt::LeftButton) {
return;
}
m_dragging = true;
m_anchor = e->position().toPoint();
m_selection = QRect(m_anchor, m_anchor);
update();
qreal eff = 0;
QPointF tl;
computeLayout(eff, tl);
const QPointF viewPos = CROP_LOCAL_POS_M(e);
const QPointF img = viewToImage(viewPos, eff, tl);
m_dragPart = hitTest(img, eff);
if (m_dragPart == HitPart::None) {
m_dragPart = HitPart::PanView;
}
if (m_dragPart == HitPart::PanView) {
m_pressView = viewPos;
m_panAtPress = m_pan;
setCursor(Qt::ClosedHandCursor);
return;
}
m_pressImg = img;
m_startSel = m_selImage;
updateCursorForHover(viewPos, eff, tl);
}
void mouseMoveEvent(QMouseEvent* e) override {
if (!m_dragging) {
if (m_image.isNull()) {
return;
}
const QPoint cur = e->position().toPoint();
m_selection = QRect(m_anchor, cur).normalized();
update();
qreal eff = 0;
QPointF tl;
computeLayout(eff, tl);
const QPointF viewPos = CROP_LOCAL_POS_M(e);
if ((e->buttons() & Qt::LeftButton) && m_dragPart == HitPart::PanView) {
m_pan = m_panAtPress + (viewPos - m_pressView);
update();
return;
}
if ((e->buttons() & Qt::LeftButton) && m_dragPart != HitPart::None && m_dragPart != HitPart::PanView) {
const QPointF img = viewToImage(viewPos, eff, tl);
applyDrag(m_dragPart, m_pressImg, img, m_startSel);
update();
return;
}
updateCursorForHover(viewPos, eff, tl);
}
void mouseReleaseEvent(QMouseEvent* e) override {
if (e->button() != Qt::LeftButton) {
return;
if (e->button() == Qt::LeftButton) {
m_dragPart = HitPart::None;
unsetCursor();
}
m_dragging = false;
update();
QWidget::mouseReleaseEvent(e);
}
private:
QTransform viewToImageTransform() const {
// 让图片按比例 fit 到 view 中居中显示
const QSizeF viewSize = size();
const QSizeF imgSize = m_image.size();
const qreal sx = viewSize.width() / imgSize.width();
const qreal sy = viewSize.height() / imgSize.height();
const qreal s = std::min(sx, sy);
const qreal drawW = imgSize.width() * s;
const qreal drawH = imgSize.height() * s;
const qreal offsetX = (viewSize.width() - drawW) / 2.0;
const qreal offsetY = (viewSize.height() - drawH) / 2.0;
void computeLayout(qreal& outEffScale, QPointF& outTopLeft) const {
const qreal vw = width();
const qreal vh = height();
const qreal iw = m_image.width();
const qreal ih = m_image.height();
if (iw <= 0 || ih <= 0 || vw <= 1 || vh <= 1) {
outEffScale = 1.0;
outTopLeft = QPointF();
return;
}
const qreal fit = std::min(vw / iw, vh / ih);
const qreal eff = fit * m_zoom;
outEffScale = eff;
outTopLeft = m_pan + QPointF((vw - iw * eff) / 2.0, (vh - ih * eff) / 2.0);
}
QTransform imageToViewTransform(qreal eff, const QPointF& tl) const {
QTransform t;
t.translate(offsetX, offsetY);
t.scale(s, s);
t.translate(tl.x(), tl.y());
t.scale(eff, eff);
return t;
}
QPointF viewToImage(const QPointF& viewPt, qreal eff, const QPointF& tl) const {
return QPointF((viewPt.x() - tl.x()) / eff, (viewPt.y() - tl.y()) / eff);
}
qreal marginImage(qreal eff) const {
return std::max<qreal>(kMinCropSidePx, kHandleViewPx / std::max(eff, 1e-6));
}
HitPart hitTest(const QPointF& img, qreal eff) const {
const qreal iw = m_image.width();
const qreal ih = m_image.height();
const QRectF boundsF(0, 0, iw, ih);
if (!boundsF.contains(img)) {
return HitPart::PanView;
}
const qreal m = marginImage(eff);
const QRect r = m_selImage.normalized();
const bool onN = std::abs(img.y() - r.top()) <= m && img.x() >= r.left() - m && img.x() <= r.right() + m;
const bool onS = std::abs(img.y() - r.bottom()) <= m && img.x() >= r.left() - m && img.x() <= r.right() + m;
const bool onW = std::abs(img.x() - r.left()) <= m && img.y() >= r.top() - m && img.y() <= r.bottom() + m;
const bool onE = std::abs(img.x() - r.right()) <= m && img.y() >= r.top() - m && img.y() <= r.bottom() + m;
const bool cnw = std::abs(img.x() - r.left()) <= m && std::abs(img.y() - r.top()) <= m;
const bool cne = std::abs(img.x() - r.right()) <= m && std::abs(img.y() - r.top()) <= m;
const bool cse = std::abs(img.x() - r.right()) <= m && std::abs(img.y() - r.bottom()) <= m;
const bool csw = std::abs(img.x() - r.left()) <= m && std::abs(img.y() - r.bottom()) <= m;
if (cnw) {
return HitPart::Nw;
}
if (cne) {
return HitPart::Ne;
}
if (cse) {
return HitPart::Se;
}
if (csw) {
return HitPart::Sw;
}
if (onN && !onW && !onE) {
return HitPart::N;
}
if (onS && !onW && !onE) {
return HitPart::S;
}
if (onW && !onN && !onS) {
return HitPart::W;
}
if (onE && !onN && !onS) {
return HitPart::E;
}
const QRect fullImage(0, 0, m_image.width(), m_image.height());
if (r.contains(img.toPoint())) {
// 选区为整图时没有「可平移的选区」，框内左键用于平移视图
if (r.normalized() == fullImage.normalized()) {
return HitPart::PanView;
}
return HitPart::Inside;
}
return HitPart::PanView;
}
void updateCursorForHover(const QPointF& viewPt, qreal eff, const QPointF& tl) {
if (m_dragPart != HitPart::None) {
return;
}
const QPointF img = viewToImage(viewPt, eff, tl);
const HitPart h = hitTest(img, eff);
switch (h) {
case HitPart::PanView:
setCursor(Qt::OpenHandCursor);
break;
case HitPart::Inside:
setCursor(Qt::SizeAllCursor);
break;
case HitPart::N:
setCursor(Qt::SizeVerCursor);
break;
case HitPart::S:
setCursor(Qt::SizeVerCursor);
break;
case HitPart::W:
setCursor(Qt::SizeHorCursor);
break;
case HitPart::E:
setCursor(Qt::SizeHorCursor);
break;
case HitPart::Nw:
case HitPart::Se:
setCursor(Qt::SizeFDiagCursor);
break;
case HitPart::Ne:
case HitPart::Sw:
setCursor(Qt::SizeBDiagCursor);
break;
default:
unsetCursor();
break;
}
}
void applyDrag(HitPart part, const QPointF& pressImg, const QPointF& curImg, const QRect& start) {
const QRect bounds(0, 0, m_image.width(), m_image.height());
QRect r = start.normalized();
const int L = r.left();
const int T = r.top();
const int R = r.right();
const int B = r.bottom();
auto clampX = [&](int x) { return std::clamp(x, bounds.left(), bounds.right()); };
auto clampY = [&](int y) { return std::clamp(y, bounds.top(), bounds.bottom()); };
switch (part) {
case HitPart::Inside: {
const QPoint delta = (curImg - pressImg).toPoint();
r.translate(delta);
r = clampRectToBounds(r, bounds);
break;
}
case HitPart::N: {
int nt = clampY(int(std::round(curImg.y())));
nt = std::min(nt, B - kMinCropSidePx);
r = QRect(L, nt, R - L + 1, B - nt + 1);
break;
}
case HitPart::S: {
int nb = clampY(int(std::round(curImg.y())));
nb = std::max(nb, T + kMinCropSidePx);
r = QRect(L, T, R - L + 1, nb - T + 1);
break;
}
case HitPart::W: {
int nl = clampX(int(std::round(curImg.x())));
nl = std::min(nl, R - kMinCropSidePx);
r = QRect(nl, T, R - nl + 1, B - T + 1);
break;
}
case HitPart::E: {
int nr = clampX(int(std::round(curImg.x())));
nr = std::max(nr, L + kMinCropSidePx);
r = QRect(L, T, nr - L + 1, B - T + 1);
break;
}
case HitPart::Nw: {
int nl = clampX(int(std::round(curImg.x())));
int nt = clampY(int(std::round(curImg.y())));
nl = std::min(nl, R - kMinCropSidePx);
nt = std::min(nt, B - kMinCropSidePx);
r = QRect(QPoint(nl, nt), QPoint(R, B)).normalized();
break;
}
case HitPart::Ne: {
int nr = clampX(int(std::round(curImg.x())));
int nt = clampY(int(std::round(curImg.y())));
nr = std::max(nr, L + kMinCropSidePx);
nt = std::min(nt, B - kMinCropSidePx);
r = QRect(QPoint(L, nt), QPoint(nr, B)).normalized();
break;
}
case HitPart::Se: {
int nr = clampX(int(std::round(curImg.x())));
int nb = clampY(int(std::round(curImg.y())));
nr = std::max(nr, L + kMinCropSidePx);
nb = std::max(nb, T + kMinCropSidePx);
r = QRect(QPoint(L, T), QPoint(nr, nb)).normalized();
break;
}
case HitPart::Sw: {
int nl = clampX(int(std::round(curImg.x())));
int nb = clampY(int(std::round(curImg.y())));
nl = std::min(nl, R - kMinCropSidePx);
nb = std::max(nb, T + kMinCropSidePx);
r = QRect(QPoint(nl, T), QPoint(R, nb)).normalized();
break;
}
case HitPart::PanView:
break;
default:
break;
}
m_selImage = clampRectToBounds(r, bounds);
if (m_selImage.isEmpty()) {
m_selImage = start;
}
}
private:
QImage m_image;
bool m_dragging = false;
QPoint m_anchor;
QRect m_selection;
QRect m_selImage;
double m_zoom = 1.0;
QPointF m_pan;
HitPart m_dragPart = HitPart::None;
QPointF m_pressImg;
QRect m_startSel;
QPointF m_pressView;
QPointF m_panAtPress;
};
ImageCropDialog::ImageCropDialog(const QString& imagePath, QWidget* parent)
@@ -160,34 +496,30 @@ ImageCropDialog::ImageCropDialog(const QString& imagePath, QWidget* parent)
}
void ImageCropDialog::loadImageOrClose() {
// Qt 默认的 image allocation limit 较小（常见为 256MB），超大分辨率图会被拒绝。
// 这里用 QImageReader 并提高 limit；同时对极端大图按像素数上限自动缩放，避免 OOM。
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
QImageReader::setAllocationLimit(1024); // MB
#endif
QImageReader reader(m_imagePath);
reader.setAutoTransform(true);
const QSize sz = reader.size();
if (sz.isValid()) {
constexpr qint64 kMaxPixels = 120LL * 1000LL * 1000LL; // 120MP
const qint64 pixels = qint64(sz.width()) * qint64(sz.height());
if (pixels > kMaxPixels) {
const double s = std::sqrt(double(kMaxPixels) / std::max<double>(1.0, double(pixels)));
const int nw = std::max(1, int(std::lround(sz.width() * s)));
const int nh = std::max(1, int(std::lround(sz.height() * s)));
reader.setScaledSize(QSize(nw, nh));
}
if (!core::image_file::probeImagePixelSize(m_imagePath, &m_sourceLogicalSize)) {
m_sourceLogicalSize = QSize();
}
m_image = reader.read();
m_image =
core::image_file::loadImageLimited(m_imagePath, core::image_decode::kPreviewMaxPixels);
if (m_image.isNull()) {
reject();
return;
}
if (!m_sourceLogicalSize.isValid() || m_sourceLogicalSize.width() <= 0 ||
m_sourceLogicalSize.height() <= 0) {
m_sourceLogicalSize = m_image.size();
}
}
void ImageCropDialog::rebuildUi() {
auto* root = new QVBoxLayout(this);
auto* hint = new QLabel(QStringLiteral("拖拽选择裁剪区域（不选则使用整张图）。"), this);
auto* hint = new QLabel(
QStringLiteral(
"默认已框选整张图。滚轮可连续缩放；拖拽边或角调整裁剪，框内拖拽移动选区；选区外或留白处左键拖动平移视图。「重置」恢复整图选区。"
" 若已链接 libvips，超大图用流式解码与预览；否则回退 Qt。确定裁剪后坐标按原图逻辑像素对齐。"),
this);
hint->setWordWrap(true);
root->addWidget(hint);
m_view = new CropView(this);
@@ -196,7 +528,7 @@ void ImageCropDialog::rebuildUi() {
auto* buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
m_okButton = buttons->button(QDialogButtonBox::Ok);
auto* resetBtn = new QPushButton(QStringLiteral("重置选择"), this);
auto* resetBtn = new QPushButton(QStringLiteral("重置"), this);
buttons->addButton(resetBtn, QDialogButtonBox::ActionRole);
connect(resetBtn, &QPushButton::clicked, this, &ImageCropDialog::onReset);
@@ -213,7 +545,14 @@ QRect ImageCropDialog::selectedRectInImagePixels() const {
if (!m_view) {
return {};
}
return m_view->selectionInImagePixels();
const QRect inPreview = m_view->selectionInImagePixels();
if (!inPreview.isValid() || m_image.isNull()) {
return {};
}
if (m_sourceLogicalSize.isValid() && m_sourceLogicalSize != m_image.size()) {
return core::image_decode::mapRectBetweenSizes(inPreview, m_image.size(), m_sourceLogicalSize);
}
return inPreview;
}
void ImageCropDialog::onReset() {
@@ -225,4 +564,3 @@ void ImageCropDialog::onReset() {
void ImageCropDialog::onOk() {
accept();
}
client/gui/dialogs/ImageCropDialog.h
+3
View File
@@ -3,6 +3,7 @@
#include <QDialog>
#include <QImage>
#include <QRect>
#include <QSize>
class QLabel;
class QPushButton;
@@ -30,5 +31,7 @@ private:
QString m_imagePath;
QImage m_image;
/// read() 前 reader.size() 得到的原图逻辑尺寸（与 m_image 可能为缩放预览不一致）
QSize m_sourceLogicalSize;
};
client/gui/dialogs/InpaintPreviewDialog.cpp
+2 -2
View File
@@ -28,7 +28,7 @@ static QScrollArea* wrapScroll(QWidget* child, QWidget* parent) {
InpaintPreviewDialog::InpaintPreviewDialog(const QString& title, QWidget* parent)
: QDialog(parent) {
setModal(true);
setMinimumSize(860, 520);
setMinimumSize(720, 480);
setWindowTitle(title);
auto* root = new QVBoxLayout(this);
@@ -49,7 +49,7 @@ InpaintPreviewDialog::InpaintPreviewDialog(const QString& title, QWidget* parent
auto* btns = new QDialogButtonBox(this);
btns->addButton(QStringLiteral("取消"), QDialogButtonBox::RejectRole);
btns->addButton(QStringLiteral("接受并写回"), QDialogButtonBox::AcceptRole);
btns->addButton(QStringLiteral("写回"), QDialogButtonBox::AcceptRole);
connect(btns, &QDialogButtonBox::accepted, this, &QDialog::accept);
connect(btns, &QDialogButtonBox::rejected, this, &QDialog::reject);
root->addWidget(btns);
client/gui/editor/EditorCanvas.cpp
+1120 -360
View File
File diff suppressed because it is too large Load Diff
client/gui/editor/EditorCanvas.h
+67 -5
View File
@@ -2,13 +2,17 @@
#include "core/domain/Project.h"
#include <atomic>
#include <QByteArray>
#include <QJsonArray>
#include <QPixmap>
#include <QPoint>
#include <QPointF>
#include <QHash>
#include <QImage>
#include <QPainterPath>
#include <QRect>
#include <QVector>
#include <QWidget>
#include <QElapsedTimer>
@@ -22,7 +26,7 @@ class QDropEvent;
class EditorCanvas final : public QWidget {
Q_OBJECT
public:
enum class Tool { Move, Zoom, CreateEntity };
enum class Tool { Move, Zoom, CreateEntity, AddHotspot, MoveHotspot };
Q_ENUM(Tool)
explicit EditorCanvas(QWidget* parent = nullptr);
@@ -81,6 +85,13 @@ public:
/// 退出「点击实体放大」状态并平滑回到进入前的视图（预览模式）
void clearPresentationEntityFocus();
void setPresentationHotspots(const QVector<core::Project::PresentationHotspot>& hotspots);
void setPresentationHotspotEditorActive(bool on);
void setPresentationHotspotPlaybackTargetEnabled(bool on);
void setSelectedPresentationHotspotId(const QString& id);
QString selectedPresentationHotspotId() const { return m_selectedPresentationHotspotId; }
void clearPresentationHotspotSelection();
void setEntities(const QVector<core::Project::Entity>& entities,
const QVector<double>& opacities01,
const QString& projectDirAbs);
@@ -105,9 +116,13 @@ public:
void cancelBlackholeCopyResolve();
/// 背景图片文件内容被外部写盘更新（路径未变）时，强制重新加载缓存
void notifyBackgroundContentChanged();
/// 黑洞修复覆盖层（独立 PNG）更新，不修改 background 原图
void notifyBlackholeOverlaysChanged();
// 与动画求值一致的原点/缩放（用于 K 帧与自动关键帧）
/// 当前帧求值后的变换原点（枢轴），与关键帧/父子偏移一致
QPointF selectedAnimatedOriginWorld() const;
/// 同 selectedAnimatedOriginWorld（语义名）
QPointF selectedEntityPivotWorld() const;
double selectedDepthScale01() const;
QPointF selectedEntityCentroidWorld() const;
double selectedDistanceScaleMultiplier() const;
@@ -145,6 +160,13 @@ signals:
void presentationEntityIntroRequested(const QString& entityId, QPointF anchorViewPoint);
/// 预览模式下应关闭介绍层（空白处轻点、Esc、开始还原缩放时由画布侧触发）
void presentationInteractionDismissed();
/// 首张背景已可绘制，或整图同步路径已就绪（用于打开工程时关闭加载对话框）
void initialBackgroundLoadFinished();
void requestAddPresentationHotspot(const QPointF& centerWorld);
void requestAddPresentationHotspotForAnimation(const QPointF& centerWorld, const QString& animationId);
void presentationHotspotMoved(const QString& id, const QPointF& centerWorld);
void selectedPresentationHotspotChanged(const QString& id);
void hotspotPlayRequested(const QString& hotspotId);
protected:
void paintEvent(QPaintEvent* e) override;
@@ -161,6 +183,14 @@ protected:
private:
void ensurePixmapLoaded() const;
void invalidatePixmap();
/// libvips + 视口分块：滚轮放大只拉高可见区域的解码分辨率（非整图降采样）
void invalidateViewportLod();
void ensureBackgroundViewport();
void tryEmitInitialBackgroundLoadFinished();
QRectF visibleWorldRectF() const;
int backgroundLogicalWidth() const;
int backgroundLogicalHeight() const;
void updateCursor();
QPointF viewToWorld(const QPointF& v) const;
@@ -169,6 +199,10 @@ private:
bool isPointNearPendingVertex(const QPointF& worldPos, int* outIndex) const;
bool pendingPolygonContains(const QPointF& worldPos) const;
int hitTestPresentationHotspot(const QPointF& worldPos) const;
/// 预览 none：热点内「播」触点命中则返回热点下标，否则 -1
int hitTestHotspotPlayControl(const QPointF& worldPos) const;
void tickPresentationZoomAnimation();
void tickPresentationHoverAnimation();
void beginPresentationZoomTowardEntity(int entityIndex);
@@ -192,10 +226,13 @@ private:
double userScale = 1.0; // 与深度距离缩放相乘
double distanceScaleCalibMult = 0.0; // 与 Project::Entity 一致；0=未校准
bool ignoreDistanceScale = false;
int priority = 1;
QPointF animatedOriginWorld;
double animatedDepthScale01 = 0.5;
double opacity = 1.0; // 0..1（由可见性轨道求值）
bool blackholeVisible = true;
QString blackholeOverlayPath;
QRect blackholeOverlayRect;
};
int hitTestEntity(const QPointF& worldPos) const;
@@ -203,11 +240,30 @@ private:
struct ToolView {
core::Project::Tool tool;
double opacity = 1.0; // 0..1
int depthZ = 0;
};
private:
QString m_projectDirAbs;
QHash<QString, QImage> m_blackholeOverlayImageCache;
QString m_bgAbsPath;
bool m_backgroundVisible = true;
mutable QSize m_bgLogicalSize; // 原图逻辑像素（与项目/实体世界坐标一致）
mutable bool m_useViewportLod = false;
mutable QImage m_bgViewportImage; // 仅覆盖 m_bgViewportCacheRect
mutable QRect m_bgViewportCacheRect;
mutable bool m_bgViewportDirty = true;
/// 记录上次视口纹理对应的「世界→屏幕」像素密度，滚轮缩放后需换更高分辨率纹理
mutable qreal m_vpCachedDensity = 0.0;
/// 递增以使进行中的后台解码结果作废（路径变更 / 缩放 / 平移需刷新纹理）
std::atomic<uint32_t> m_vpToken{0};
std::atomic<bool> m_vpDecodeInFlight{false};
/// 全图缩略解码成功后置位，下一帧强制区域解码以尽快变清晰
mutable bool m_vpPreferRegionDecode = false;
bool m_initialBgLoadFinishedEmitted = false;
QImage m_bhCopyPatch; // 黑洞「复制背景」预览：原图子区域
QPoint m_bhCopyPatchOrigin;
bool m_bhCopyPatchValid = false;
mutable QPixmap m_bgPixmap;
mutable bool m_pixmapDirty = true;
mutable QImage m_bgImage; // 原背景（用于抠图/填充）
@@ -226,6 +282,12 @@ private:
bool m_gridVisible = true;
bool m_checkerboardVisible = true;
bool m_presentationPreviewMode = false;
bool m_presentationHotspotEditorActive = false;
bool m_presentationHotspotPlaybackTargetEnabled = false;
QVector<core::Project::PresentationHotspot> m_presentationHotspots;
QString m_selectedPresentationHotspotId;
int m_draggingHotspotIndex = -1;
QPointF m_hotspotDragOffsetWorld;
Tool m_tool = Tool::Move;
EntityCreateSegmentMode m_entityCreateSegmentMode = EntityCreateSegmentMode::Manual;
@@ -236,9 +298,9 @@ private:
bool m_draggingEntity = false;
bool m_drawingEntity = false;
QPointF m_lastMouseView;
// 拖动以“实体原点 animatedOriginWorld”为基准，避免因缩放导致 rect/topLeft 抖动
QPointF m_entityDragOffsetOriginWorld;
QPointF m_entityDragStartAnimatedOrigin;
// 拖动锚点（局部坐标，相对形心）：解决拖动过程中距离缩放变化导致的“抖动/闪烁”
QPointF m_entityDragAnchorLocal;
QPointF m_entityDragStartCentroidWorld;
// 拖动性能优化：拖动过程中不逐点修改 polygonWorld，而是保留基准形状+增量参数，在 paint 时做变换预览
bool m_dragPreviewActive = false;
QVector<QPointF> m_dragPolyBase;
client/gui/editor/EntityCutoutUtils.cpp
+17 -1
View File
@@ -68,7 +68,23 @@ QImage extractEntityImage(const QImage& bg, const QVector<QPointF>& polyWorld, Q
outTopLeftWorld = {};
return {};
}
const QRect bbox = clampRectToImage(path.boundingRect().toAlignedRect(), bg.size());
// bbox 必须只由顶点 min/max 推导，不能依赖 QPainterPath::boundingRect()：
// 在坐标含小数时，boundingRect 的浮点误差会造成稳定的“右下”偏移。
double minX = polyWorld.front().x();
double minY = polyWorld.front().y();
double maxX = polyWorld.front().x();
double maxY = polyWorld.front().y();
for (const auto& p : polyWorld) {
minX = std::min(minX, double(p.x()));
minY = std::min(minY, double(p.y()));
maxX = std::max(maxX, double(p.x()));
maxY = std::max(maxY, double(p.y()));
}
const int left = std::clamp(int(std::floor(minX)), 0, bg.width());
const int top = std::clamp(int(std::floor(minY)), 0, bg.height());
const int right = std::clamp(int(std::ceil(maxX)), 0, bg.width() - 1);
const int bottom = std::clamp(int(std::ceil(maxY)), 0, bg.height() - 1);
const QRect bbox = clampRectToImage(QRect(QPoint(left, top), QPoint(right, bottom)), bg.size());
if (bbox.isNull()) {
outTopLeftWorld = {};
return {};
client/gui/library/ResourceLibraryDock.cpp
+1 -1
View File
@@ -255,7 +255,7 @@ void ResourceLibraryDock::rebuildCombinedList() {
it->setText(r.displayName);
it->setIcon(QIcon(makePreviewPixmap(r)));
it->setData(Qt::UserRole, i);
it->setToolTip(r.resourceId);
it->setToolTip({});
list->addItem(it);
}
}
client/gui/main_window/MainWindow.cpp
+1697 -654
View File
File diff suppressed because it is too large Load Diff
client/gui/main_window/MainWindow.h
+50 -3
View File
@@ -24,6 +24,7 @@ class QMenu;
class QFrame;
class QIcon;
class QPushButton;
class QListWidget;
class QSlider;
class QStackedWidget;
class QToolButton;
@@ -32,12 +33,14 @@ class QTreeWidgetItem;
class QWidget;
class EditorCanvas;
class TimelineWidget;
class TimelineEditorModel;
namespace gui {
class BackgroundPropertySection;
class BlackholePropertySection;
class EntityPropertySection;
class ToolPropertySection;
class CameraPropertySection;
class HotspotPropertySection;
class EntityIntroPopup;
class ResourceLibraryDock;
}
@@ -81,15 +84,18 @@ private:
void computeDepthAsync();
// UI 状态分三种：
// - Welcome：未打开项目。只显示欢迎页，其它 dock 一律隐藏，视图开关禁用。
// - Editor：已打开项目。显示编辑页，按默认规则显示 dock，同时允许用户通过“视图”菜单控制。
// - EntityEditor：静态实体编辑（activeAnimationId=none，不显示摄像机）。
// - AnimationEditor：动画编辑（真实动画方案，可编辑摄像机/时间轴）。
// - HotspotEditor：展示热点布点（要求：项目已打开且背景不为空）。
// - Preview：预览展示。用于全流程完成后的展示（要求：项目已打开且背景不为空）。
enum class UiMode { Welcome, Editor, Preview };
enum class UiMode { Welcome, EntityEditor, AnimationEditor, HotspotEditor, Preview };
void createMenus(); // 菜单和工具栏
void createFileMenu(); // 文件菜单
void createEditMenu(); // 编辑菜单
void createHelpMenu(); // 帮助菜单
void createViewMenu(); // 视图菜单
void createAnimationMenu();
void createWindowMenu(); // 窗口菜单（资源库等）
void createProjectTreeDock();
void createTimelineDock();
@@ -109,6 +115,8 @@ private:
void showPreviewPage();
void refreshWelcomeRecentList();
void openProjectFromPath(const QString& dir);
/// 打开/新建工程后：模态「加载中」直至首张背景可显示（无背景则立即继续）
void presentWorkspaceEditorWithBlockingInitialLoad();
void refreshPreviewPage();
void refreshEditorPage();
void applyTimelineFromProject();
@@ -116,6 +124,20 @@ private:
void refreshDopeSheet();
void setPreviewRequested(bool preview);
void syncPreviewPlaybackBar();
void stopEditorPlayback();
void stopPreviewPlayback();
void togglePreviewPlayback();
void startPreviewPlayback();
QString effectivePreviewAnimationId() const;
void refreshPreviewSchemeCombo();
void onPreviewSchemeComboChanged(int idx);
void switchPreviewSchemeAdjacent(int delta);
void requestPreviewSchemeSwitchTo(const QString& id, bool warmupDialog);
void updatePreviewEdgeArrowsHover(const QPointF& posInCanvasHost);
QVector<QString> previewAnimationSchemeIdsNonNone() const;
void syncHotspotEnterPreviewCombo();
void syncEditorRailForMode();
QStackedWidget* m_centerStack = nullptr;
QWidget* m_pageWelcome = nullptr;
@@ -132,6 +154,7 @@ private:
gui::EntityPropertySection* m_entityPropertySection = nullptr;
gui::ToolPropertySection* m_toolPropertySection = nullptr;
gui::CameraPropertySection* m_cameraPropertySection = nullptr;
gui::HotspotPropertySection* m_hotspotPropertySection = nullptr;
QToolButton* m_btnCreateEntity = nullptr;
ToolOptionPopup* m_createEntityPopup = nullptr;
QToolButton* m_btnToggleDepthOverlay = nullptr;
@@ -139,6 +162,8 @@ private:
EditorCanvas* m_editorCanvas = nullptr;
QTreeWidget* m_projectTree = nullptr;
QStackedWidget* m_rightTopDockStack = nullptr;
QListWidget* m_hotspotAnimationList = nullptr;
QDockWidget* m_dockProjectTree = nullptr;
QDockWidget* m_dockProperties = nullptr;
QDockWidget* m_dockTimeline = nullptr;
@@ -155,6 +180,7 @@ private:
QAction* m_actionToggleResourceLibrary = nullptr;
QAction* m_actionEnterPreview = nullptr;
QAction* m_actionBackToEditor = nullptr;
QAction* m_actionAnimationSettings = nullptr;
QAction* m_actionCanvasWorldAxes = nullptr;
QAction* m_actionCanvasAxisValues = nullptr;
QAction* m_actionCanvasGrid = nullptr;
@@ -192,6 +218,8 @@ private:
void refreshPropertyPanel();
void refreshEntityPropertyPanelFast();
void syncProjectTreeFromCanvasSelection();
/// 右侧项目树+属性列最小宽度：随当前属性页与树内容 minimumSizeHint 抬高，窄于内容时不再缩小。
void updateRightDockColumnMinimumWidthFromContent();
bool m_timelineScrubbing = false;
bool m_entityDragging = false;
@@ -200,7 +228,24 @@ private:
int m_currentFrame = 0;
bool m_playing = false;
QTimer* m_playTimer = nullptr;
QString m_previewAnimationId;
bool m_animationRequested = false;
bool m_hotspotRequested = false;
QString m_selectedHotspotId;
QToolButton* m_railBtnMove = nullptr;
QToolButton* m_railBtnZoom = nullptr;
QToolButton* m_railBtnFit = nullptr;
QToolButton* m_btnRailAddHotspot = nullptr;
QToolButton* m_btnRailMoveHotspot = nullptr;
QToolButton* m_btnHotspotEnterPreview = nullptr;
QToolButton* m_previewBackToCanvasBtn = nullptr;
int m_previewFrame = 0;
bool m_previewPlaying = false;
QTimer* m_previewPlayTimer = nullptr;
TimelineWidget* m_timeline = nullptr;
TimelineEditorModel* m_timelineModel = nullptr;
QToolButton* m_btnPlay = nullptr;
QComboBox* m_schemeSelector = nullptr;
// 时间轴区间选择（用于逐帧贴图动画）
@@ -214,7 +259,9 @@ private:
gui::EntityIntroPopup* m_entityIntroPopup = nullptr;
QFrame* m_previewPlaybackBar = nullptr;
QToolButton* m_previewBtnPlay = nullptr;
QToolButton* m_previewBtnPause = nullptr;
QComboBox* m_previewSchemeCombo = nullptr;
QToolButton* m_previewArrowLeft = nullptr;
QToolButton* m_previewArrowRight = nullptr;
gui::ResourceLibraryDock* m_resourceLibraryDockWidget = nullptr;
core::library::ResourceLibraryProvider* m_resourceLibraryProvider = nullptr;
client/gui/params/ParamControls.cpp
+125 -35
View File
@@ -1,10 +1,18 @@
#include "params/ParamControls.h"
#include "widgets/CompactNumericSpinBox.h"
#include <algorithm>
#include <cmath>
#include <QAbstractSpinBox>
#include <QApplication>
#include <QDoubleSpinBox>
#include <QHBoxLayout>
#include <QSizePolicy>
#include <QSlider>
#include <QSpinBox>
#include <QWidget>
namespace gui {
@@ -12,7 +20,7 @@ Float01ParamControl::Float01ParamControl(QWidget* parent)
: QWidget(parent) {
auto* row = new QHBoxLayout(this);
row->setContentsMargins(0, 0, 0, 0);
row->setSpacing(8);
row->setSpacing(4);
m_slider = new QSlider(Qt::Horizontal, this);
m_slider->setRange(0, 1000);
@@ -20,12 +28,11 @@ Float01ParamControl::Float01ParamControl(QWidget* parent)
m_slider->setPageStep(10);
row->addWidget(m_slider, 1);
m_spin = new QDoubleSpinBox(this);
m_spin = new CompactDoubleSpinBox(this, 52);
m_spin->setRange(0.0, 1.0);
m_spin->setDecimals(3);
m_spin->setSingleStep(0.01);
m_spin->setMinimumWidth(72);
row->addWidget(m_spin);
row->addWidget(m_spin, 0);
connect(m_slider, &QSlider::valueChanged, this, [this]() { syncFromSlider(); });
connect(m_spin, qOverload<double>(&QDoubleSpinBox::valueChanged), this, [this]() { syncFromSpin(); });
@@ -73,59 +80,142 @@ Vec2ParamControl::Vec2ParamControl(QWidget* parent)
: QWidget(parent) {
auto* row = new QHBoxLayout(this);
row->setContentsMargins(0, 0, 0, 0);
row->setSpacing(8);
row->setSpacing(3);
m_x = new QDoubleSpinBox(this);
m_x->setRange(-1e9, 1e9);
m_x->setDecimals(2);
m_x->setSingleStep(1.0);
m_x->setMinimumWidth(72);
row->addWidget(m_x, 1);
constexpr int kMaxW = 72;
m_sx = new CompactIntSpinBox(this, kMaxW);
m_sx->setRange(-10'000'000, 10'000'000);
m_sx->setSingleStep(1);
m_sx->setAccelerated(true);
row->addWidget(m_sx, 0);
m_y = new QDoubleSpinBox(this);
m_y->setRange(-1e9, 1e9);
m_y->setDecimals(2);
m_y->setSingleStep(1.0);
m_y->setMinimumWidth(72);
row->addWidget(m_y, 1);
m_sy = new CompactIntSpinBox(this, kMaxW);
m_sy->setRange(-10'000'000, 10'000'000);
m_sy->setSingleStep(1);
m_sy->setAccelerated(true);
row->addWidget(m_sy, 0);
row->addStretch(1);
connect(m_x, qOverload<double>(&QDoubleSpinBox::valueChanged), this, [this]() { emitIfChanged(); });
connect(m_y, qOverload<double>(&QDoubleSpinBox::valueChanged), this, [this]() { emitIfChanged(); });
connect(m_sx, qOverload<int>(&QSpinBox::valueChanged), this, [this]() { emitIfChanged(); });
connect(m_sy, qOverload<int>(&QSpinBox::valueChanged), this, [this]() { emitIfChanged(); });
setValue(0.0, 0.0);
setValue(0, 0);
}
void Vec2ParamControl::setEnabled(bool on) {
QWidget::setEnabled(on);
if (m_x) m_x->setEnabled(on);
if (m_y) m_y->setEnabled(on);
if (m_sx) m_sx->setEnabled(on);
if (m_sy) m_sy->setEnabled(on);
}
void Vec2ParamControl::setValue(double x, double y) {
void Vec2ParamControl::setValue(int x, int y) {
m_block = true;
if (m_x) m_x->setValue(x);
if (m_y) m_y->setValue(y);
if (m_sx) m_sx->setValue(x);
if (m_sy) m_sy->setValue(y);
m_lastX = x;
m_lastY = y;
m_block = false;
}
double Vec2ParamControl::x() const { return m_x ? m_x->value() : 0.0; }
double Vec2ParamControl::y() const { return m_y ? m_y->value() : 0.0; }
int Vec2ParamControl::x() const { return m_sx ? m_sx->value() : 0; }
int Vec2ParamControl::y() const { return m_sy ? m_sy->value() : 0; }
bool Vec2ParamControl::isActivelyEditing() const {
QWidget* fw = QApplication::focusWidget();
for (QWidget* w = fw; w; w = w->parentWidget()) {
if (w == this) {
return true;
}
}
return false;
}
void Vec2ParamControl::emitIfChanged() {
if (m_block || !m_x || !m_y) return;
const double nx = m_x->value();
const double ny = m_y->value();
auto nearEq = [](double a, double b) {
const double scale = std::max({1.0, std::abs(a), std::abs(b)});
return std::abs(a - b) <= 1e-4 * scale;
if (m_block || !m_sx || !m_sy) return;
const int nx = m_sx->value();
const int ny = m_sy->value();
if (nx == m_lastX && ny == m_lastY) return;
m_lastX = nx;
m_lastY = ny;
emit valueChanged(nx, ny);
}
Vec2DoubleParamControl::Vec2DoubleParamControl(QWidget* parent)
: QWidget(parent) {
auto* row = new QHBoxLayout(this);
row->setContentsMargins(0, 0, 0, 0);
row->setSpacing(4);
// 属性栏里的数值输入框不要太宽，否则会挤占面板空间。
// 坐标/中心等字段通常是整数显示，因此固定更紧凑的宽度即可（仍允许键盘输入）。
constexpr int kMaxW = 78;
auto makeSpin = [kMaxW](QDoubleSpinBox* box) {
box->setObjectName(QStringLiteral("CompactNumericSpin"));
box->setButtonSymbols(QAbstractSpinBox::UpDownArrows);
box->setFocusPolicy(Qt::StrongFocus);
box->setKeyboardTracking(false);
// 坐标轴/位置统一用整数（仍可直接键盘输入）
box->setDecimals(0);
box->setRange(-1.0e7, 1.0e7);
box->setSingleStep(1.0);
box->setAccelerated(true);
box->setMinimumWidth(60);
box->setMaximumWidth(kMaxW);
box->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
};
if (nearEq(nx, m_lastX) && nearEq(ny, m_lastY)) return;
m_sx = new QDoubleSpinBox(this);
makeSpin(m_sx);
row->addWidget(m_sx, 0);
m_sy = new QDoubleSpinBox(this);
makeSpin(m_sy);
row->addWidget(m_sy, 0);
connect(m_sx, qOverload<double>(&QDoubleSpinBox::valueChanged), this, [this]() { emitIfChanged(); });
connect(m_sy, qOverload<double>(&QDoubleSpinBox::valueChanged), this, [this]() { emitIfChanged(); });
setValue(0.0, 0.0);
}
void Vec2DoubleParamControl::setEnabled(bool on) {
QWidget::setEnabled(on);
if (m_sx) m_sx->setEnabled(on);
if (m_sy) m_sy->setEnabled(on);
}
void Vec2DoubleParamControl::setValue(double x, double y) {
m_block = true;
const double rx = std::round(x);
const double ry = std::round(y);
if (m_sx) m_sx->setValue(rx);
if (m_sy) m_sy->setValue(ry);
m_lastX = rx;
m_lastY = ry;
m_block = false;
}
double Vec2DoubleParamControl::x() const { return m_sx ? m_sx->value() : 0.0; }
double Vec2DoubleParamControl::y() const { return m_sy ? m_sy->value() : 0.0; }
bool Vec2DoubleParamControl::isActivelyEditing() const {
QWidget* fw = QApplication::focusWidget();
for (QWidget* w = fw; w; w = w->parentWidget()) {
if (w == this) {
return true;
}
}
return false;
}
void Vec2DoubleParamControl::emitIfChanged() {
if (m_block || !m_sx || !m_sy) return;
const double nx = m_sx->value();
const double ny = m_sy->value();
if (qFuzzyCompare(nx + 1.0, m_lastX + 1.0) && qFuzzyCompare(ny + 1.0, m_lastY + 1.0)) return;
m_lastX = nx;
m_lastY = ny;
emit valueChanged(nx, ny);
}
} // namespace gui
client/gui/params/ParamControls.h
+34 -8
View File
@@ -4,11 +4,10 @@
class QDoubleSpinBox;
class QSlider;
class QLabel;
class QSpinBox;
namespace gui {
// 0..1 浮点参数：Slider + DoubleSpinBox（可复用）
class Float01ParamControl final : public QWidget {
Q_OBJECT
public:
@@ -31,15 +30,43 @@ private:
bool m_block = false;
};
// Vec2 参数：两个 DoubleSpinBox（可复用）
class Vec2ParamControl final : public QWidget {
Q_OBJECT
public:
explicit Vec2ParamControl(QWidget* parent = nullptr);
void setValue(int x, int y);
[[nodiscard]] int x() const;
[[nodiscard]] int y() const;
[[nodiscard]] bool isActivelyEditing() const;
void setEnabled(bool on);
signals:
void valueChanged(int x, int y);
private:
void emitIfChanged();
QSpinBox* m_sx = nullptr;
QSpinBox* m_sy = nullptr;
bool m_block = false;
int m_lastX = 0;
int m_lastY = 0;
};
/// 世界坐标等：可直接键盘输入小数，带宽幅
class Vec2DoubleParamControl final : public QWidget {
Q_OBJECT
public:
explicit Vec2DoubleParamControl(QWidget* parent = nullptr);
void setValue(double x, double y);
double x() const;
double y() const;
[[nodiscard]] double x() const;
[[nodiscard]] double y() const;
[[nodiscard]] bool isActivelyEditing() const;
void setEnabled(bool on);
@@ -49,12 +76,11 @@ signals:
private:
void emitIfChanged();
QDoubleSpinBox* m_x = nullptr;
QDoubleSpinBox* m_y = nullptr;
QDoubleSpinBox* m_sx = nullptr;
QDoubleSpinBox* m_sy = nullptr;
bool m_block = false;
double m_lastX = 0.0;
double m_lastY = 0.0;
};
} // namespace gui
client/gui/props/BackgroundPropertySection.cpp
+9 -9
View File
@@ -1,6 +1,7 @@
#include "props/BackgroundPropertySection.h"
#include <QCheckBox>
#include "widgets/PropertyPanelControls.h"
#include <QFormLayout>
#include <QLabel>
#include <QVBoxLayout>
@@ -10,23 +11,22 @@ namespace gui {
BackgroundPropertySection::BackgroundPropertySection(QWidget* parent)
: PropertySectionWidget(parent) {
auto* lay = new QVBoxLayout(this);
lay->setContentsMargins(0, 0, 0, 0);
lay->setSpacing(6);
polishPropertyVBoxLayout(lay);
auto* form = new QFormLayout();
form->setContentsMargins(0, 0, 0, 0);
form->setSpacing(6);
polishPropertyFormLayout(form);
m_sizeLabel = new QLabel(QStringLiteral("-"), this);
m_sizeLabel->setTextInteractionFlags(Qt::TextSelectableByMouse);
m_sizeLabel->setWordWrap(true);
form->addRow(QStringLiteral("背景尺寸"), m_sizeLabel);
m_showBackground = new QCheckBox(QStringLiteral("显示背景"), this);
m_showBackground->setToolTip(QStringLiteral("是否绘制背景图"));
m_showBackground = new PropertyPanelCheckBox(QStringLiteral("显示背景"), this);
m_showBackground->setToolTip({});
form->addRow(QString(), m_showBackground);
m_depthOverlay = new QCheckBox(QStringLiteral("叠加深度"), this);
m_depthOverlay->setToolTip(QStringLiteral("在背景上叠加深度伪彩图"));
m_depthOverlay = new PropertyPanelCheckBox(QStringLiteral("叠加深度"), this);
m_depthOverlay->setToolTip({});
form->addRow(QString(), m_depthOverlay);
lay->addLayout(form);
client/gui/props/BlackholePropertySection.cpp
+7 -5
View File
@@ -1,5 +1,7 @@
#include "props/BlackholePropertySection.h"
#include "widgets/PropertyPanelControls.h"
#include <QFormLayout>
#include <QLabel>
#include <QVBoxLayout>
@@ -9,17 +11,17 @@ namespace gui {
BlackholePropertySection::BlackholePropertySection(QWidget* parent)
: PropertySectionWidget(parent) {
auto* lay = new QVBoxLayout(this);
lay->setContentsMargins(0, 0, 0, 0);
lay->setSpacing(6);
polishPropertyVBoxLayout(lay);
auto* form = new QFormLayout();
form->setContentsMargins(0, 0, 0, 0);
form->setSpacing(6);
polishPropertyFormLayout(form);
m_name = new QLabel(this);
m_status = new QLabel(this);
m_method = new QLabel(this);
m_method->setWordWrap(true);
for (QLabel* lab : {m_name, m_status, m_method}) {
lab->setWordWrap(true);
}
form->addRow(QStringLiteral("黑洞"), m_name);
form->addRow(QStringLiteral("是否解决"), m_status);
client/gui/props/CameraPropertySection.cpp
+16 -16
View File
@@ -4,6 +4,9 @@
#include <QCheckBox>
#include <QDoubleSpinBox>
#include "widgets/CompactNumericSpinBox.h"
#include "widgets/PropertyPanelControls.h"
#include <QFormLayout>
#include <QLabel>
#include <QLineEdit>
@@ -13,32 +16,29 @@ namespace gui {
CameraPropertySection::CameraPropertySection(QWidget* parent) : PropertySectionWidget(parent) {
auto* lay = new QVBoxLayout(this);
lay->setContentsMargins(0, 0, 0, 0);
lay->setSpacing(6);
polishPropertyVBoxLayout(lay);
auto* form = new QFormLayout();
form->setContentsMargins(0, 0, 0, 0);
form->setSpacing(6);
polishPropertyFormLayout(form);
m_name = new QLineEdit(this);
m_name = new PropertyPanelLineEdit(this);
m_name->setPlaceholderText(QStringLiteral("显示名称…"));
polishPropertyStretchyTextField(m_name);
form->addRow(QStringLiteral("名称"), m_name);
m_center = new Vec2ParamControl(this);
m_center->setToolTip(QStringLiteral("摄像机中心（世界坐标），与画布上黄色圆点一致"));
m_center->setToolTip({});
form->addRow(QStringLiteral("中心"), m_center);
m_viewScale = new QDoubleSpinBox(this);
m_viewScale = new CompactDoubleSpinBox(this, 56);
m_viewScale->setRange(1e-4, 1000.0);
m_viewScale->setDecimals(5);
m_viewScale->setSingleStep(0.01);
m_viewScale->setToolTip(QStringLiteral(
"视口缩放：在参考分辨率 1600×900 下的像素/世界单位比（与预览、画布上镜头框一致）；"
"不随当前窗口大小改变镜头覆盖的世界范围。数值越小，可见的世界范围越大。"));
m_viewScale->setToolTip({});
form->addRow(QStringLiteral("缩放"), m_viewScale);
m_activePreview = new QCheckBox(QStringLiteral("用作预览展示镜头"), this);
m_activePreview->setToolTip(QStringLiteral("进入预览展示时，按该摄像机在当前帧的位置与缩放呈现画面"));
m_activePreview = new PropertyPanelCheckBox(QStringLiteral("用作预览展示镜头"), this);
m_activePreview->setToolTip({});
form->addRow(QStringLiteral("预览"), m_activePreview);
lay->addLayout(form);
@@ -47,7 +47,7 @@ CameraPropertySection::CameraPropertySection(QWidget* parent) : PropertySectionW
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_center, &Vec2ParamControl::valueChanged, this, [this](int x, int y) { emit centerEdited(x, y); });
connect(m_viewScale, qOverload<double>(&QDoubleSpinBox::valueChanged), this,
&CameraPropertySection::viewScaleEdited);
connect(m_activePreview, &QCheckBox::toggled, this, &CameraPropertySection::activePreviewToggled);
@@ -69,7 +69,7 @@ void CameraPropertySection::clearDisconnected() {
}
if (m_center) {
m_center->blockSignals(true);
m_center->setValue(0.0, 0.0);
m_center->setValue(0, 0);
m_center->blockSignals(false);
}
if (m_viewScale) {
@@ -91,9 +91,9 @@ void CameraPropertySection::applyState(const CameraPropertyUiState& s) {
m_name->setText(s.displayName);
m_name->blockSignals(false);
}
if (m_center) {
if (m_center && !m_center->isActivelyEditing()) {
m_center->blockSignals(true);
m_center->setValue(s.centerWorld.x(), s.centerWorld.y());
m_center->setValue(qRound(s.centerWorld.x()), qRound(s.centerWorld.y()));
m_center->blockSignals(false);
}
if (m_viewScale) {
client/gui/props/CameraPropertySection.h
+1 -1
View File
@@ -33,7 +33,7 @@ public:
signals:
void displayNameCommitted(const QString& text);
void centerEdited(double x, double y);
void centerEdited(int x, int y);
void viewScaleEdited(double viewScale);
void activePreviewToggled(bool on);
client/gui/props/EntityPropertySection.cpp
+135 -66
View File
@@ -3,7 +3,11 @@
#include "params/ParamControls.h"
#include <QDoubleSpinBox>
#include "widgets/CompactNumericSpinBox.h"
#include "widgets/PropertyPanelControls.h"
#include <QFormLayout>
#include <QFrame>
#include <QHBoxLayout>
#include <QCheckBox>
#include <QLabel>
@@ -20,101 +24,143 @@ namespace gui {
EntityPropertySection::EntityPropertySection(QWidget* parent)
: PropertySectionWidget(parent) {
auto* lay = new QVBoxLayout(this);
lay->setContentsMargins(0, 0, 0, 0);
lay->setSpacing(6);
polishPropertyVBoxLayout(lay);
auto* form = new QFormLayout();
form->setContentsMargins(0, 0, 0, 0);
form->setSpacing(6);
polishPropertyFormLayout(form);
m_name = new QLineEdit(this);
m_name = new PropertyPanelLineEdit(this);
m_name->setPlaceholderText(QStringLiteral("显示名称"));
m_name->setToolTip(QStringLiteral("仅显示用；内部 id 不变"));
m_name->setToolTip({});
polishPropertyStretchyTextField(m_name);
form->addRow(QStringLiteral("名称"), m_name);
m_depth = new QLabel(QStringLiteral("-"), this);
m_distScale = new QLabel(QStringLiteral("-"), this);
for (QLabel* lab : {m_depth, m_distScale}) {
lab->setTextInteractionFlags(Qt::TextSelectableByMouse);
lab->setWordWrap(true);
}
form->addRow(QStringLiteral("深度"), m_depth);
form->addRow(QStringLiteral("距离缩放"), m_distScale);
m_pivotLabel = new QLabel(QStringLiteral("中心坐标"), this);
m_pivot = new Vec2ParamControl(this);
m_pivot->setToolTip(QStringLiteral("枢轴在世界坐标中的位置（限制在轮廓包络内），用于重定位局部原点"));
form->addRow(m_pivotLabel, m_pivot);
m_centerLabel = new QLabel(QStringLiteral("中心"), this);
m_centerPosition = new Vec2DoubleParamControl(this);
m_centerPosition->setToolTip(
QStringLiteral("无父级：形心世界坐标。有父级：形心相对父级形心的偏移。"));
form->addRow(m_centerLabel, m_centerPosition);
m_centroidLabel = new QLabel(QStringLiteral("位置"), this);
m_centroid = new Vec2ParamControl(this);
m_centroid->setToolTip(QStringLiteral("实体几何质心的世界坐标；修改将整体平移实体"));
form->addRow(m_centroidLabel, m_centroid);
m_relativeLabel = new QLabel(QStringLiteral("相对位置"), this);
m_relativeToOwnCenter = new Vec2DoubleParamControl(this);
m_relativeToOwnCenter->setToolTip(QStringLiteral("变换原点相对自身形心的偏移"));
form->addRow(m_relativeLabel, m_relativeToOwnCenter);
m_userScale = new QDoubleSpinBox(this);
m_priority = new CompactIntSpinBox(this, 72);
m_priority->setRange(-1000000, 1000000);
m_priority->setSingleStep(1);
m_priority->setAccelerated(true);
m_priority->setToolTip(QStringLiteral("优先级越高越靠上。背景为 0，实体默认 1；同优先级按距离缩放/深度决定覆盖关系。"));
form->addRow(QStringLiteral("优先级"), m_priority);
m_userScale = new CompactDoubleSpinBox(this, 56);
m_userScale->setRange(0.05, 20.0);
m_userScale->setDecimals(3);
m_userScale->setSingleStep(0.05);
m_userScale->setValue(1.0);
m_userScale->setToolTip(QStringLiteral("人为整体缩放，与深度距离缩放相乘"));
m_userScale->setToolTip({});
form->addRow(QStringLiteral("整体缩放"), m_userScale);
m_ignoreDistanceScale = new QCheckBox(QStringLiteral("不受距离缩放影响"), this);
m_ignoreDistanceScale->setToolTip(QStringLiteral("开启后实体不受深度驱动的距离缩放影响，仅受整体缩放影响（对话气泡默认开启）"));
m_ignoreDistanceScale = new PropertyPanelCheckBox(QStringLiteral("不受距离缩放影响"), this);
m_ignoreDistanceScale->setToolTip({});
form->addRow(QStringLiteral("距离缩放"), m_ignoreDistanceScale);
m_visible = new QCheckBox(QString(), this);
m_visible = new PropertyPanelCheckBox(QString(), this);
m_visible->setChecked(true);
m_visible->setToolTip(QStringLiteral("随帧变化：在当前帧切换会写入可见性关键帧（10帧淡入淡出）"));
m_visible->setToolTip({});
form->addRow(QStringLiteral("可见性"), m_visible);
m_spritePreview = new QLabel(this);
// 贴图预览必须稳定占位：若用 setPixmap(pm.scaled(label->size()))，QLabel 的 sizeHint 会被 pixmap 反向撑大，
// 再触发布局扩张，形成“拖动刷新属性 → 预览越来越大”的正反馈。
// 因此固定预览区域尺寸，pixmap 仅按该尺寸缩放。
constexpr int kSpritePreviewW = 200;
constexpr int kSpritePreviewH = 120;
m_spritePreview->setFixedSize(kSpritePreviewW, kSpritePreviewH);
m_spritePreview->setFrameShape(QFrame::StyledPanel);
m_spritePreview->setAlignment(Qt::AlignCenter);
m_spritePreview->setText(QStringLiteral("无图像"));
form->addRow(QStringLiteral("贴图"), m_spritePreview);
m_btnEditSprite = new PropertyPanelPushButton(QStringLiteral("编辑"), this);
m_btnEditSprite->setToolTip(QStringLiteral("编辑当前帧贴图/逐帧动画"));
form->addRow(QString(), m_btnEditSprite);
lay->addLayout(form);
auto* sep = new QFrame(this);
sep->setObjectName(QStringLiteral("PropertySectionSeparator"));
sep->setFrameShape(QFrame::HLine);
lay->addWidget(sep);
m_introHeader = new QWidget(this);
polishPropertyStretchyTextField(m_introHeader);
auto* headLay = new QHBoxLayout(m_introHeader);
headLay->setContentsMargins(0, 2, 0, 2);
headLay->setSpacing(6);
headLay->setContentsMargins(0, 6, 0, 2);
headLay->setSpacing(4);
m_introToggle = new QToolButton(m_introHeader);
m_introToggle->setAutoRaise(true);
m_introToggle->setToolButtonStyle(Qt::ToolButtonTextOnly);
m_introToggle->setCursor(Qt::PointingHandCursor);
m_introToggle->setToolTip(QStringLiteral("展开或折叠介绍设置"));
m_introToggle->setToolTip(QStringLiteral("展开/折叠介绍"));
m_introToggle->setText(QStringLiteral("▶"));
m_introToggle->setFixedWidth(22);
m_introToggle->setFixedHeight(22);
auto* introTitleLab = new QLabel(QStringLiteral("介绍"), m_introHeader);
introTitleLab->setStyleSheet(QStringLiteral("QLabel { font-weight: 600; }"));
introTitleLab->setObjectName(QStringLiteral("PropertyPanelHeading"));
headLay->addWidget(m_introToggle, 0, Qt::AlignVCenter);
headLay->addWidget(introTitleLab, 1, Qt::AlignVCenter);
m_introContent = new QWidget(this);
polishPropertyStretchyTextField(m_introContent);
auto* introLay = new QVBoxLayout(m_introContent);
introLay->setContentsMargins(8, 4, 0, 0);
introLay->setSpacing(6);
polishPropertyVBoxLayout(introLay);
introLay->setContentsMargins(0, 4, 0, 0);
m_introTitle = new QLineEdit(m_introContent);
m_introTitle = new PropertyPanelLineEdit(m_introContent);
m_introTitle->setPlaceholderText(QStringLiteral("标题"));
introLay->addWidget(new QLabel(QStringLiteral("标题"), m_introContent));
introLay->addWidget(m_introTitle);
m_introBody = new QTextEdit(m_introContent);
m_introBody->setPlaceholderText(QStringLiteral("正文（纯文本）"));
m_introBody->setMaximumHeight(100);
m_introBody = new PropertyPanelTextEdit(m_introContent);
m_introBody->setPlaceholderText(QStringLiteral("正文"));
m_introBody->setMaximumHeight(80);
introLay->addWidget(new QLabel(QStringLiteral("正文"), m_introContent));
introLay->addWidget(m_introBody);
m_introImages = new QListWidget(m_introContent);
m_introImages->setMinimumHeight(72);
m_introImages->setToolTip(QStringLiteral("配图相对路径列表；使用下方按钮从文件添加"));
m_introImages->setObjectName(QStringLiteral("PropertyPanelListWidget"));
m_introImages->setMinimumHeight(56);
m_introImages->setToolTip({});
m_introImages->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_introImages->setWordWrap(true);
introLay->addWidget(new QLabel(QStringLiteral("配图"), m_introContent));
introLay->addWidget(m_introImages);
m_btnIntroAddImage = new PropertyPanelPushButton(QStringLiteral("添加"), m_introContent);
m_btnIntroRemoveImage = new PropertyPanelPushButton(QStringLiteral("删除"), m_introContent);
m_btnIntroAddImage->setFixedWidth(52);
m_btnIntroRemoveImage->setFixedWidth(52);
m_btnIntroAddImage->setToolTip(QStringLiteral("添加配图"));
m_btnIntroRemoveImage->setToolTip(QStringLiteral("删除当前选中的配图"));
auto* imgRow = new QHBoxLayout();
m_btnIntroAddImage = new QPushButton(QStringLiteral("添加配图…"), m_introContent);
m_btnIntroRemoveImage = new QPushButton(QStringLiteral("移除选中"), m_introContent);
imgRow->addWidget(m_btnIntroAddImage);
imgRow->addWidget(m_btnIntroRemoveImage);
imgRow->setContentsMargins(0, 0, 0, 0);
imgRow->setSpacing(8);
imgRow->addWidget(m_btnIntroAddImage, 0);
imgRow->addWidget(m_btnIntroRemoveImage, 0);
imgRow->addStretch(1);
introLay->addLayout(imgRow);
m_introVideo = new QLineEdit(m_introContent);
m_introVideo = new PropertyPanelLineEdit(m_introContent);
m_introVideo->setPlaceholderText(QStringLiteral("可选：视频相对路径（如 assets/entities/xxx.mp4）"));
introLay->addWidget(new QLabel(QStringLiteral("视频路径（预留）"), m_introContent));
introLay->addWidget(m_introVideo);
@@ -141,11 +187,14 @@ EntityPropertySection::EntityPropertySection(QWidget* parent)
emit displayNameCommitted(m_name->text());
}
});
connect(m_pivot, &Vec2ParamControl::valueChanged, this, &EntityPropertySection::pivotEdited);
connect(m_centroid, &Vec2ParamControl::valueChanged, this, &EntityPropertySection::centroidEdited);
connect(m_centerPosition, &Vec2DoubleParamControl::valueChanged, this, &EntityPropertySection::centerPositionEdited);
connect(m_relativeToOwnCenter, &Vec2DoubleParamControl::valueChanged, this,
&EntityPropertySection::relativeToOwnCenterEdited);
connect(m_priority, qOverload<int>(&QSpinBox::valueChanged), this, &EntityPropertySection::priorityEdited);
connect(m_userScale, qOverload<double>(&QDoubleSpinBox::valueChanged), this, &EntityPropertySection::userScaleEdited);
connect(m_ignoreDistanceScale, &QCheckBox::toggled, this, &EntityPropertySection::ignoreDistanceScaleToggled);
connect(m_visible, &QCheckBox::toggled, this, &EntityPropertySection::visibleToggled);
connect(m_btnEditSprite, &QPushButton::clicked, this, &EntityPropertySection::spriteEditRequested);
connect(m_introTitle, &QLineEdit::textChanged, this, [this](const QString&) { scheduleIntroPersist(); });
connect(m_introBody, &QTextEdit::textChanged, this, [this]() { scheduleIntroPersist(); });
@@ -189,16 +238,15 @@ void EntityPropertySection::clearDisconnected() {
}
if (m_depth) m_depth->setText(QStringLiteral("-"));
if (m_distScale) m_distScale->setText(QStringLiteral("-"));
if (m_pivot) m_pivot->setValue(0.0, 0.0);
if (m_centroid) m_centroid->setValue(0.0, 0.0);
if (m_pivotLabel) m_pivotLabel->setText(QStringLiteral("中心坐标"));
if (m_centroidLabel) m_centroidLabel->setText(QStringLiteral("位置"));
if (m_pivot) {
m_pivot->setToolTip(QStringLiteral("枢轴在世界坐标中的位置（限制在轮廓包络内），用于重定位局部原点"));
}
if (m_centroid) {
m_centroid->setToolTip(QStringLiteral("实体几何质心的世界坐标；修改将整体平移实体"));
if (m_centerPosition) m_centerPosition->setValue(0, 0);
if (m_relativeToOwnCenter) m_relativeToOwnCenter->setValue(0, 0);
if (m_priority) {
m_priority->blockSignals(true);
m_priority->setValue(1);
m_priority->blockSignals(false);
}
if (m_centerLabel) m_centerLabel->setText(QStringLiteral("中心"));
if (m_relativeLabel) m_relativeLabel->setText(QStringLiteral("相对位置"));
if (m_userScale) {
m_userScale->blockSignals(true);
m_userScale->setValue(1.0);
@@ -230,6 +278,10 @@ void EntityPropertySection::clearDisconnected() {
m_introVideo->blockSignals(false);
}
if (m_introImages) m_introImages->clear();
if (m_spritePreview) {
m_spritePreview->setPixmap(QPixmap());
m_spritePreview->setText(QStringLiteral("无图像"));
}
setIntroSectionExpanded(true);
m_introBulkUpdate = false;
}
@@ -248,26 +300,23 @@ void EntityPropertySection::applyState(const EntityPropertyUiState& s) {
}
if (m_depth) m_depth->setText(QString::number(s.depthZ));
if (m_distScale) m_distScale->setText(s.distanceScaleText);
if (m_pivotLabel) {
m_pivotLabel->setText(QStringLiteral("中心坐标"));
if (m_centerLabel) {
m_centerLabel->setText(s.hasParent ? QStringLiteral("相对中心") : QStringLiteral("世界中心"));
}
if (m_centroidLabel) {
m_centroidLabel->setText(QStringLiteral("位置"));
if (m_relativeLabel) {
m_relativeLabel->setText(QStringLiteral("相对位置"));
}
if (m_pivot) {
m_pivot->setToolTip(
s.parentRelativeMode
? QStringLiteral("枢轴相对父对象的坐标；修改将写入相对父对象的位置关键帧")
: QStringLiteral("枢轴在世界坐标中的位置（限制在轮廓包络内），用于重定位局部原点"));
if (m_centerPosition && !m_centerPosition->isActivelyEditing()) {
m_centerPosition->setValue(s.centerPosition.x(), s.centerPosition.y());
}
if (m_centroid) {
m_centroid->setToolTip(
s.parentRelativeMode
? QStringLiteral("几何质心相对父对象的坐标；修改将写入相对父对象的位置关键帧")
: QStringLiteral("实体几何质心的世界坐标；修改将整体平移实体"));
if (m_relativeToOwnCenter && !m_relativeToOwnCenter->isActivelyEditing()) {
m_relativeToOwnCenter->setValue(s.relativeToOwnCenter.x(), s.relativeToOwnCenter.y());
}
if (m_priority) {
m_priority->blockSignals(true);
m_priority->setValue(s.priority);
m_priority->blockSignals(false);
}
if (m_pivot) m_pivot->setValue(s.pivot.x(), s.pivot.y());
if (m_centroid) m_centroid->setValue(s.centroid.x(), s.centroid.y());
if (m_userScale) {
m_userScale->blockSignals(true);
m_userScale->setValue(s.userScale);
@@ -283,6 +332,24 @@ void EntityPropertySection::applyState(const EntityPropertyUiState& s) {
m_visible->setChecked(s.visible);
m_visible->blockSignals(false);
}
if (m_spritePreview && !s.spritePreview.isNull()) {
const QSize target = m_spritePreview->contentsRect().size().isValid()
? m_spritePreview->contentsRect().size()
: m_spritePreview->size();
const quint64 key = static_cast<quint64>(s.spritePreview.cacheKey());
if (m_spritePreviewCacheKey != key || m_spritePreviewLastTargetSize != target) {
const QPixmap pm = QPixmap::fromImage(s.spritePreview);
m_spritePreview->setPixmap(
pm.scaled(target, Qt::KeepAspectRatio, Qt::SmoothTransformation));
m_spritePreviewCacheKey = key;
m_spritePreviewLastTargetSize = target;
}
} else if (m_spritePreview) {
m_spritePreview->setPixmap(QPixmap());
m_spritePreview->setText(QStringLiteral("无图像"));
m_spritePreviewCacheKey = 0;
m_spritePreviewLastTargetSize = {};
}
if (m_introTitle) {
m_introTitle->blockSignals(true);
m_introTitle->setText(s.intro.title);
@@ -343,11 +410,13 @@ core::EntityIntroContent EntityPropertySection::introSnapshot() const {
void EntityPropertySection::setEditingEnabled(bool on) {
if (m_name) m_name->setEnabled(on);
if (m_pivot) m_pivot->setEnabled(on);
if (m_centroid) m_centroid->setEnabled(on);
if (m_centerPosition) m_centerPosition->setEnabled(on);
if (m_relativeToOwnCenter) m_relativeToOwnCenter->setEnabled(on);
if (m_priority) m_priority->setEnabled(on);
if (m_userScale) m_userScale->setEnabled(on);
if (m_ignoreDistanceScale) m_ignoreDistanceScale->setEnabled(on);
if (m_visible) m_visible->setEnabled(on);
if (m_btnEditSprite) m_btnEditSprite->setEnabled(on);
if (m_introHeader) m_introHeader->setEnabled(on);
if (m_introToggle) m_introToggle->setEnabled(on);
if (m_introTitle) m_introTitle->setEnabled(on);
client/gui/props/EntityPropertySection.h
+26 -10
View File
@@ -4,11 +4,14 @@
#include "props/PropertySectionWidget.h"
#include <QPointF>
#include <QImage>
#include <QString>
#include <QtGlobal>
class QLabel;
class QLineEdit;
class QDoubleSpinBox;
class QSpinBox;
class QCheckBox;
class QTextEdit;
class QListWidget;
@@ -18,7 +21,7 @@ class QTimer;
class QWidget;
namespace gui {
class Vec2ParamControl;
class Vec2DoubleParamControl;
}
namespace gui {
@@ -27,12 +30,16 @@ struct EntityPropertyUiState {
QString displayName;
int depthZ = 0;
QString distanceScaleText;
QPointF pivot;
QPointF centroid;
/// 中心：无父级时为形心世界坐标（与画布十字一致，用于距离/位置缩放）；有父级时为形心相对父级形心的偏移。
QPointF centerPosition;
/// 相对位置：变换原点相对自身形心（世界坐标差）。
QPointF relativeToOwnCenter;
bool hasParent = false;
int priority = 1;
double userScale = 1.0;
bool ignoreDistanceScale = false;
bool visible = true;
bool parentRelativeMode = false;
QImage spritePreview;
core::EntityIntroContent intro;
};
@@ -50,8 +57,11 @@ public:
signals:
void displayNameCommitted(const QString& text);
void pivotEdited(double x, double y);
void centroidEdited(double x, double y);
/// 编辑中心：无父为形心世界坐标；有父为形心相对父形心的偏移（整体平移实体）
void centerPositionEdited(double x, double y);
/// 编辑相对自身形心的原点偏移（改枢轴、外形世界位置不变）
void relativeToOwnCenterEdited(double x, double y);
void priorityEdited(int value);
void userScaleEdited(double value);
void ignoreDistanceScaleToggled(bool on);
// 可见性（动画通道）：在当前帧写关键帧
@@ -59,6 +69,7 @@ signals:
/// 介绍字段变更后防抖触发，由主窗口写入工程
void introContentEdited();
void introAddImageRequested();
void spriteEditRequested();
private:
void scheduleIntroPersist();
@@ -67,13 +78,18 @@ private:
QLineEdit* m_name = nullptr;
QLabel* m_depth = nullptr;
QLabel* m_distScale = nullptr;
QLabel* m_pivotLabel = nullptr;
QLabel* m_centroidLabel = nullptr;
Vec2ParamControl* m_pivot = nullptr;
Vec2ParamControl* m_centroid = nullptr;
QLabel* m_centerLabel = nullptr;
QLabel* m_relativeLabel = nullptr;
QSpinBox* m_priority = nullptr;
Vec2DoubleParamControl* m_centerPosition = nullptr;
Vec2DoubleParamControl* m_relativeToOwnCenter = nullptr;
QDoubleSpinBox* m_userScale = nullptr;
QCheckBox* m_ignoreDistanceScale = nullptr;
QCheckBox* m_visible = nullptr;
QLabel* m_spritePreview = nullptr;
QPushButton* m_btnEditSprite = nullptr;
quint64 m_spritePreviewCacheKey = 0;
QSize m_spritePreviewLastTargetSize;
QLineEdit* m_introTitle = nullptr;
QTextEdit* m_introBody = nullptr;
client/gui/props/HotspotPropertySection.cpp
+151
View File
@@ -0,0 +1,151 @@
#include "props/HotspotPropertySection.h"
#include <QComboBox>
#include <QFormLayout>
#include <QHash>
#include <QLabel>
#include <QListWidget>
#include <QMenu>
#include <QPushButton>
#include <QVBoxLayout>
namespace gui {
HotspotPropertySection::HotspotPropertySection(QWidget* parent) : PropertySectionWidget(parent) {
auto* root = new QVBoxLayout(this);
root->setContentsMargins(0, 0, 0, 0);
auto* title = new QLabel(QStringLiteral("已添加热点"), this);
root->addWidget(title);
m_hotspotList = new QListWidget(this);
m_hotspotList->setObjectName(QStringLiteral("PropertyPanelListWidget"));
m_hotspotList->setMinimumHeight(120);
m_hotspotList->setContextMenuPolicy(Qt::CustomContextMenu);
root->addWidget(m_hotspotList);
auto* form = new QFormLayout();
form->setSpacing(6);
root->addLayout(form);
m_targetAnim = new QComboBox(this);
m_targetAnim->setMinimumWidth(120);
form->addRow(QStringLiteral("目标"), m_targetAnim);
m_btnDelete = new QPushButton(QStringLiteral("删除"), this);
root->addWidget(m_btnDelete);
connect(m_targetAnim, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this](int) {
if (m_hotspotId.isEmpty() || !m_targetAnim) {
return;
}
const QString aid = m_targetAnim->currentData().toString();
emit targetAnimationChanged(m_hotspotId, aid);
});
connect(m_hotspotList, &QListWidget::currentItemChanged, this, [this](QListWidgetItem* current, QListWidgetItem*) {
const QString hotspotId = current ? current->data(Qt::UserRole).toString() : QString();
if (hotspotId == m_hotspotId) {
return;
}
m_hotspotId = hotspotId;
emit hotspotSelected(hotspotId);
});
connect(m_hotspotList, &QListWidget::customContextMenuRequested, this, [this](const QPoint& pos) {
if (!m_hotspotList) {
return;
}
auto* item = m_hotspotList->itemAt(pos);
if (!item) {
return;
}
const QString hotspotId = item->data(Qt::UserRole).toString();
if (hotspotId.isEmpty()) {
return;
}
m_hotspotList->setCurrentItem(item);
QMenu menu(this);
auto* actDelete = menu.addAction(QStringLiteral("移除热点"));
if (menu.exec(m_hotspotList->viewport()->mapToGlobal(pos)) == actDelete) {
emit deleteRequested(hotspotId);
}
});
connect(m_btnDelete, &QPushButton::clicked, this, [this]() {
if (!m_hotspotId.isEmpty()) {
emit deleteRequested(m_hotspotId);
}
});
}
void HotspotPropertySection::clearDisconnected() {
m_hotspotId.clear();
}
void HotspotPropertySection::applyState(const QVector<core::Project::PresentationHotspot>& hotspots,
const QString& selectedHotspotId,
const QVector<QPair<QString, QString>>& animIdToLabelNonNone) {
m_hotspotId = selectedHotspotId;
if (!m_targetAnim || !m_hotspotList) {
return;
}
QString targetAnimationId;
QHash<QString, QString> animLabelById;
for (const auto& p : animIdToLabelNonNone) {
animLabelById.insert(p.first, p.second);
}
m_hotspotList->blockSignals(true);
m_hotspotList->clear();
QListWidgetItem* selectedItem = nullptr;
for (const auto& hotspot : hotspots) {
QString text = hotspot.id;
const QString animLabel = animLabelById.value(hotspot.targetAnimationId);
if (!animLabel.isEmpty()) {
text += QStringLiteral(" -> ") + animLabel;
} else if (!hotspot.targetAnimationId.isEmpty()) {
text += QStringLiteral(" -> ") + hotspot.targetAnimationId;
} else {
text += QStringLiteral(" -> 未设");
}
auto* item = new QListWidgetItem(text, m_hotspotList);
item->setData(Qt::UserRole, hotspot.id);
if (hotspot.id == selectedHotspotId) {
selectedItem = item;
targetAnimationId = hotspot.targetAnimationId;
}
}
if (selectedItem) {
m_hotspotList->setCurrentItem(selectedItem);
} else {
m_hotspotList->setCurrentRow(-1);
m_hotspotId.clear();
}
m_hotspotList->blockSignals(false);
m_targetAnim->blockSignals(true);
m_targetAnim->clear();
m_targetAnim->addItem(QStringLiteral("未设"), QString());
for (const auto& p : animIdToLabelNonNone) {
m_targetAnim->addItem(p.second, p.first);
}
int idx = -1;
for (int i = 0; i < m_targetAnim->count(); ++i) {
if (m_targetAnim->itemData(i).toString() == targetAnimationId) {
idx = i;
break;
}
}
if (idx >= 0) {
m_targetAnim->setCurrentIndex(idx);
} else {
m_targetAnim->setCurrentIndex(0);
}
m_targetAnim->blockSignals(false);
const bool ok = !m_hotspotId.isEmpty() && m_targetAnim->count() > 0;
m_targetAnim->setEnabled(ok);
if (m_btnDelete) {
m_btnDelete->setEnabled(!m_hotspotId.isEmpty());
}
}
} // namespace gui
client/gui/props/HotspotPropertySection.h
+36
View File
@@ -0,0 +1,36 @@
#pragma once
#include "core/domain/Project.h"
#include "props/PropertySectionWidget.h"
#include <QString>
class QComboBox;
class QListWidget;
class QPushButton;
namespace gui {
class HotspotPropertySection final : public PropertySectionWidget {
Q_OBJECT
public:
explicit HotspotPropertySection(QWidget* parent = nullptr);
void clearDisconnected();
void applyState(const QVector<core::Project::PresentationHotspot>& hotspots,
const QString& selectedHotspotId,
const QVector<QPair<QString, QString>>& animIdToLabelNonNone);
signals:
void hotspotSelected(const QString& hotspotId);
void targetAnimationChanged(const QString& hotspotId, const QString& animationId);
void deleteRequested(const QString& hotspotId);
private:
QString m_hotspotId;
QListWidget* m_hotspotList = nullptr;
QComboBox* m_targetAnim = nullptr;
QPushButton* m_btnDelete = nullptr;
};
} // namespace gui
client/gui/props/ToolPropertySection.cpp
+38 -19
View File
@@ -11,6 +11,9 @@
#include <QLineEdit>
#include <QSlider>
#include <QSpinBox>
#include "widgets/CompactNumericSpinBox.h"
#include "widgets/PropertyPanelControls.h"
#include <QVBoxLayout>
namespace gui {
@@ -18,43 +21,50 @@ namespace gui {
ToolPropertySection::ToolPropertySection(QWidget* parent)
: PropertySectionWidget(parent) {
auto* lay = new QVBoxLayout(this);
lay->setContentsMargins(0, 0, 0, 0);
lay->setSpacing(6);
polishPropertyVBoxLayout(lay);
auto* form = new QFormLayout();
form->setContentsMargins(0, 0, 0, 0);
form->setSpacing(6);
polishPropertyFormLayout(form);
m_text = new QLineEdit(this);
m_text = new PropertyPanelLineEdit(this);
m_text->setPlaceholderText(QStringLiteral("对话内容…"));
polishPropertyStretchyTextField(m_text);
form->addRow(QStringLiteral("文字"), m_text);
m_positionLabel = new QLabel(QStringLiteral("位置"), this);
m_position = new Vec2ParamControl(this);
m_position->setToolTip(QStringLiteral("工具在世界坐标中的位置"));
m_position->setToolTip({});
form->addRow(m_positionLabel, m_position);
m_priority = new CompactIntSpinBox(this, 72);
m_priority->setRange(-1000000, 1000000);
m_priority->setSingleStep(1);
m_priority->setAccelerated(true);
m_priority->setToolTip(QStringLiteral("优先级越高越靠上。背景为 0；工具默认 10。"));
form->addRow(QStringLiteral("优先级"), m_priority);
m_pointerT = new QSlider(Qt::Horizontal, this);
m_pointerT->setRange(0, 1000);
m_pointerT->setSingleStep(10);
m_pointerT->setPageStep(50);
m_pointerT->setValue(500);
m_pointerT->setToolTip(QStringLiteral("发言实体位置"));
m_pointerT->setToolTip({});
form->addRow(QStringLiteral("指向"), m_pointerT);
m_fontPx = new QSpinBox(this);
m_fontPx = new CompactIntSpinBox(this);
m_fontPx->setRange(8, 120);
m_fontPx->setSingleStep(1);
m_fontPx->setValue(18);
form->addRow(QStringLiteral("字号"), m_fontPx);
m_align = new QComboBox(this);
m_align = new PropertyPanelComboBox(this);
m_align->addItems({QStringLiteral("左对齐"), QStringLiteral("居中"), QStringLiteral("右对齐")});
polishPropertyStretchyTextField(m_align);
form->addRow(QStringLiteral("对齐"), m_align);
m_visible = new QCheckBox(QString(), this);
m_visible = new PropertyPanelCheckBox(QString(), this);
m_visible->setChecked(true);
m_visible->setToolTip(QStringLiteral("随帧变化：在当前帧切换会写入可见性关键帧"));
m_visible->setToolTip({});
form->addRow(QStringLiteral("可见性"), m_visible);
lay->addLayout(form);
@@ -67,11 +77,13 @@ ToolPropertySection::ToolPropertySection(QWidget* parent)
connect(m_fontPx, qOverload<int>(&QSpinBox::valueChanged), this, &ToolPropertySection::fontPxChanged);
connect(m_align, qOverload<int>(&QComboBox::currentIndexChanged), this, &ToolPropertySection::alignChanged);
connect(m_position, &Vec2ParamControl::valueChanged, this, &ToolPropertySection::positionEdited);
connect(m_priority, qOverload<int>(&QSpinBox::valueChanged), this, &ToolPropertySection::priorityEdited);
connect(m_visible, &QCheckBox::toggled, this, &ToolPropertySection::visibleToggled);
}
void ToolPropertySection::setEditingEnabled(bool on) {
for (auto* w : {static_cast<QWidget*>(m_text), static_cast<QWidget*>(m_position),
static_cast<QWidget*>(m_priority),
static_cast<QWidget*>(m_pointerT),
static_cast<QWidget*>(m_fontPx), static_cast<QWidget*>(m_align),
static_cast<QWidget*>(m_visible)}) {
@@ -89,10 +101,15 @@ void ToolPropertySection::clearDisconnected() {
if (m_positionLabel) m_positionLabel->setText(QStringLiteral("位置"));
if (m_position) {
m_position->blockSignals(true);
m_position->setToolTip(QStringLiteral("工具在世界坐标中的位置"));
m_position->setValue(0.0, 0.0);
m_position->setToolTip({});
m_position->setValue(0, 0);
m_position->blockSignals(false);
}
if (m_priority) {
m_priority->blockSignals(true);
m_priority->setValue(10);
m_priority->blockSignals(false);
}
if (m_pointerT) {
m_pointerT->blockSignals(true);
m_pointerT->setValue(500);
@@ -125,15 +142,17 @@ void ToolPropertySection::applyState(const ToolPropertyUiState& s) {
if (m_positionLabel) {
m_positionLabel->setText(QStringLiteral("位置"));
}
if (m_position) {
if (m_position && !m_position->isActivelyEditing()) {
m_position->blockSignals(true);
m_position->setToolTip(
s.parentRelativeMode
? QStringLiteral("工具相对父对象的位置；修改将写入相对父对象的位置关键帧")
: QStringLiteral("工具在世界坐标中的位置"));
m_position->setValue(s.position.x(), s.position.y());
m_position->setToolTip({});
m_position->setValue(qRound(s.position.x()), qRound(s.position.y()));
m_position->blockSignals(false);
}
if (m_priority) {
m_priority->blockSignals(true);
m_priority->setValue(s.priority);
m_priority->blockSignals(false);
}
if (m_pointerT) {
m_pointerT->blockSignals(true);
m_pointerT->setValue(std::clamp(s.pointerTThousandths, 0, 1000));
client/gui/props/ToolPropertySection.h
+4 -1
View File
@@ -23,6 +23,7 @@ struct ToolPropertyUiState {
QString text;
QPointF position;
bool parentRelativeMode = false;
int priority = 10;
int pointerTThousandths = 500; // bubblePointerT01 * 1000，0=左 1000=右
int fontPx = 18;
int alignIndex = 1; // 0=left,1=center,2=right
@@ -43,13 +44,15 @@ signals:
void pointerTChanged(int thousandths);
void fontPxChanged(int px);
void alignChanged(int alignIndex);
void positionEdited(double x, double y);
void positionEdited(int x, int y);
void priorityEdited(int value);
// 可见性（动画通道）：在当前帧写关键帧
void visibleToggled(bool on);
private:
QLabel* m_positionLabel = nullptr;
Vec2ParamControl* m_position = nullptr;
QSpinBox* m_priority = nullptr;
QLineEdit* m_text = nullptr;
QSlider* m_pointerT = nullptr;
QSpinBox* m_fontPx = nullptr;
client/gui/timeline/TimelineEditorModel.h
+62
View File
@@ -0,0 +1,62 @@
#pragma once
#include "core/domain/Project.h"
#include <QColor>
#include <QPoint>
#include <QString>
#include <QVector>
// TimelineEditorModel：把时间轴的“可视数据 + 选择状态 + 命中测试结果”从 Widget 拆出来，
// 便于支持多轨、统一交互逻辑，并降低 TimelineWidget 的复杂度。
//
// 阶段1最小实现：仅负责存储轨道视图数据与选择状态；Widget 仍自行处理鼠标事件，
// 但数据不再用固定 4 条 QVector<int> 传递。
class TimelineEditorModel final {
public:
enum class TrackKind { Location, UserScale, Image, Visibility };
struct KeyRef {
TrackKind kind {TrackKind::Location};
int frame {-1};
};
struct TrackView {
TrackKind kind {TrackKind::Location};
QString label;
QColor color;
QVector<int> keyframes; // sorted unique frames
};
void clear() {
m_tracks.clear();
clearSelection();
clearInterval();
}
void setTracks(QVector<TrackView> tracks) { m_tracks = std::move(tracks); }
const QVector<TrackView>& tracks() const { return m_tracks; }
void clearSelection() { m_hasSelectedKey = false; m_selected = {}; }
void setSelectedKey(const KeyRef& ref) { m_hasSelectedKey = (ref.frame >= 0); m_selected = ref; }
bool hasSelectedKey() const { return m_hasSelectedKey; }
const KeyRef& selectedKey() const { return m_selected; }
void clearInterval() { m_selStart = -1; m_selEnd = -1; }
void setInterval(int a, int b) {
if (a < 0 || b < 0) { clearInterval(); return; }
m_selStart = std::min(a, b);
m_selEnd = std::max(a, b);
}
int intervalStart() const { return m_selStart; }
int intervalEnd() const { return m_selEnd; }
private:
QVector<TrackView> m_tracks;
bool m_hasSelectedKey {false};
KeyRef m_selected;
int m_selStart {-1};
int m_selEnd {-1};
};
client/gui/timeline/TimelineWidget.cpp
+61 -15
View File
@@ -1,5 +1,7 @@
#include "timeline/TimelineWidget.h"
#include "timeline/TimelineEditorModel.h"
#include <algorithm>
#include <cmath>
@@ -38,7 +40,11 @@ TimelineWidget::TimelineWidget(QWidget* parent)
// 单行紧凑：标尺 + 轨道（帧号画在播放头处，随坐标轴滚动）
setMinimumHeight(kRulerHeight + 18 + 6);
setFocusPolicy(Qt::StrongFocus);
setToolTip(QStringLiteral("片段时间轴(固定 0-600)：左键拖动播放头；滚轮：逐帧"));
setToolTip({});
}
void TimelineWidget::setModel(TimelineEditorModel* model) {
m_model = model;
}
void TimelineWidget::resizeEvent(QResizeEvent* e) {
@@ -47,8 +53,10 @@ void TimelineWidget::resizeEvent(QResizeEvent* e) {
}
void TimelineWidget::setFrameRange(int start, int end) {
(void)start;
(void)end;
m_start = std::max(0, start);
m_end = std::max(m_start + 1, end);
m_currentFrame = std::clamp(m_currentFrame, m_start, m_end - 1);
setSelectionRange(m_selStart, m_selEnd);
update();
}
@@ -57,7 +65,7 @@ void TimelineWidget::setCurrentFrame(int frame) {
}
void TimelineWidget::setCurrentFrameProgrammatic(int frame) {
const int f = std::clamp(frame, kStart, kEnd - 1);
const int f = std::clamp(frame, m_start, m_end - 1);
if (m_currentFrame == f) {
return;
}
@@ -74,8 +82,8 @@ void TimelineWidget::setSelectionRange(int start, int end) {
}
const int lo = std::min(start, end);
const int hi = std::max(start, end);
m_selStart = std::clamp(lo, kStart, kEnd - 1);
m_selEnd = std::clamp(hi, m_selStart, kEnd - 1);
m_selStart = std::clamp(lo, m_start, m_end - 1);
m_selEnd = std::clamp(hi, m_selStart, m_end - 1);
update();
}
@@ -111,6 +119,29 @@ void TimelineWidget::setKeyframeTracks(const QVector<int>& locFrames,
m_selKeyFrame = -1;
emit keyframeSelectionChanged(m_selKeyKind, m_selKeyFrame);
}
if (m_model) {
QVector<TimelineEditorModel::TrackView> tracks;
tracks.reserve(4);
tracks.push_back({TimelineEditorModel::TrackKind::Image, QStringLiteral("图像"), QColor(70, 130, 240), m_imgFrames});
tracks.push_back({TimelineEditorModel::TrackKind::Location, QStringLiteral("位置"), QColor(240, 110, 40), m_locFrames});
tracks.push_back({TimelineEditorModel::TrackKind::UserScale, QStringLiteral("缩放"), QColor(80, 190, 90), m_scaleFrames});
tracks.push_back({TimelineEditorModel::TrackKind::Visibility, QStringLiteral("显隐"), QColor(160, 100, 230), m_visFrames});
m_model->setTracks(std::move(tracks));
if (m_selKeyKind == KeyKind::None) {
m_model->clearSelection();
} else {
TimelineEditorModel::TrackKind kind = TimelineEditorModel::TrackKind::Location;
switch (m_selKeyKind) {
case KeyKind::Location: kind = TimelineEditorModel::TrackKind::Location; break;
case KeyKind::UserScale: kind = TimelineEditorModel::TrackKind::UserScale; break;
case KeyKind::Image: kind = TimelineEditorModel::TrackKind::Image; break;
case KeyKind::Visibility: kind = TimelineEditorModel::TrackKind::Visibility; break;
default: break;
}
m_model->setSelectedKey({kind, m_selKeyFrame});
}
m_model->setInterval(m_selStart, m_selEnd);
}
update();
}
@@ -131,6 +162,21 @@ void TimelineWidget::setToolKeyframeTracks(const QVector<int>& locFrames,
m_selKeyFrame = -1;
emit keyframeSelectionChanged(m_selKeyKind, m_selKeyFrame);
}
if (m_model) {
QVector<TimelineEditorModel::TrackView> tracks;
tracks.reserve(2);
tracks.push_back({TimelineEditorModel::TrackKind::Location, QStringLiteral("位置"), QColor(240, 110, 40), m_locFrames});
tracks.push_back({TimelineEditorModel::TrackKind::Visibility, QStringLiteral("显隐"), QColor(160, 100, 230), m_visFrames});
m_model->setTracks(std::move(tracks));
if (m_selKeyKind == KeyKind::None) {
m_model->clearSelection();
} else {
TimelineEditorModel::TrackKind kind = TimelineEditorModel::TrackKind::Location;
if (m_selKeyKind == KeyKind::Visibility) kind = TimelineEditorModel::TrackKind::Visibility;
m_model->setSelectedKey({kind, m_selKeyFrame});
}
m_model->setInterval(m_selStart, m_selEnd);
}
update();
}
@@ -151,8 +197,8 @@ QRect TimelineWidget::keyAreaRect() const {
}
double TimelineWidget::frameToXf(double frame) const {
const double pxf = double(contentWidth()) / double(std::max(1, kEnd - kStart));
return double(contentLeft()) + (frame - double(kStart)) * pxf;
const double pxf = double(contentWidth()) / double(std::max(1, m_end - m_start));
return double(contentLeft()) + (frame - double(m_start)) * pxf;
}
int TimelineWidget::frameToX(int frame) const {
@@ -160,8 +206,8 @@ int TimelineWidget::frameToX(int frame) const {
}
double TimelineWidget::xToFramef(int x) const {
const double pxf = double(contentWidth()) / double(std::max(1, kEnd - kStart));
return double(kStart) + double(x - contentLeft()) / std::max(pxf, 1e-9);
const double pxf = double(contentWidth()) / double(std::max(1, m_end - m_start));
return double(m_start) + double(x - contentLeft()) / std::max(pxf, 1e-9);
}
int TimelineWidget::xToFrame(int x) const {
@@ -169,7 +215,7 @@ int TimelineWidget::xToFrame(int x) const {
}
void TimelineWidget::setFrameInternal(int frame, bool commit) {
const int f = std::clamp(frame, kStart, kEnd - 1);
const int f = std::clamp(frame, m_start, m_end - 1);
// 松手时若帧未变：只发 committed，禁止再发 scrubbed，否则主窗口会双次求值/刷新导致帧号与红线闪烁
if (m_currentFrame == f) {
if (commit) {
@@ -194,9 +240,9 @@ void TimelineWidget::paintEvent(QPaintEvent*) {
const QRect cr = contentRect();
const QRect kr = keyAreaRect();
const QRect rr = rulerRect();
const double fLeft = double(kStart);
const int visMin = kStart;
const int visMax = kEnd;
const double fLeft = double(m_start);
const int visMin = m_start;
const int visMax = m_end;
auto frameVisible = [&](int fr) { return fr >= visMin && fr <= visMax; };
@@ -292,7 +338,7 @@ void TimelineWidget::paintEvent(QPaintEvent*) {
p.setBrush(palette().alternateBase());
p.drawRoundedRect(rr, 3, 3);
const double pxf = double(contentWidth()) / double(std::max(1, kEnd - kStart));
const double pxf = double(contentWidth()) / double(std::max(1, m_end - m_start));
const int major = pickMajorStep(pxf);
const int minor = pickMinorStep(major);
QPen minorPen(QColor(60, 60, 60, 100));
client/gui/timeline/TimelineWidget.h
+9 -4
View File
@@ -3,13 +3,13 @@
#include <QWidget>
class QResizeEvent;
class TimelineEditorModel;
class TimelineWidget final : public QWidget {
Q_OBJECT
public:
explicit TimelineWidget(QWidget* parent = nullptr);
// 兼容旧接口：NLA/片段系统下时间轴始终固定为 0..600（local frame）。
void setFrameRange(int start, int end);
void setCurrentFrame(int frame);
/// 由主窗口同步工程帧时调用：不发射 frameScrubbed，避免与拖动/刷新打架造成数字闪烁
@@ -20,6 +20,9 @@ public:
int selectionStart() const { return m_selStart; }
int selectionEnd() const { return m_selEnd; }
void setModel(TimelineEditorModel* model);
TimelineEditorModel* model() const { return m_model; }
// 轨道数据直接由上层提供（通常来自当前条带引用的 clip）。
void setKeyframeTracks(const QVector<int>& locFrames,
const QVector<int>& scaleFrames,
@@ -63,9 +66,9 @@ private:
void setFrameInternal(int frame, bool commit);
static constexpr int kStart = 0;
static constexpr int kEnd = 600; // exclusive for mapping, inclusive for UI labels
int m_currentFrame = 0; // local frame: 0..599
int m_start = 0;
int m_end = 600; // exclusive for mapping
int m_currentFrame = 0;
int m_selStart = -1;
int m_selEnd = -1;
@@ -83,4 +86,6 @@ private:
KeyKind m_selKeyKind = KeyKind::None;
int m_selKeyFrame = -1;
TimelineEditorModel* m_model = nullptr; // non-owning
};
client/gui/widgets/CompactNumericSpinBox.cpp
+34
View File
@@ -0,0 +1,34 @@
#include "widgets/CompactNumericSpinBox.h"
#include <QAbstractSpinBox>
#include <QSizePolicy>
namespace gui {
namespace {
void polishCompact(QAbstractSpinBox* box, int maxWidthPx) {
if (!box) {
return;
}
box->setObjectName(QStringLiteral("CompactNumericSpin"));
box->setButtonSymbols(QAbstractSpinBox::UpDownArrows);
box->setFocusPolicy(Qt::StrongFocus);
box->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
box->setMinimumWidth(22);
box->setMaximumWidth(maxWidthPx);
}
} // namespace
CompactIntSpinBox::CompactIntSpinBox(QWidget* parent, int maxWidthPx)
: QSpinBox(parent) {
polishCompact(this, maxWidthPx);
}
CompactDoubleSpinBox::CompactDoubleSpinBox(QWidget* parent, int maxWidthPx)
: QDoubleSpinBox(parent) {
polishCompact(this, maxWidthPx);
}
} // namespace gui
client/gui/widgets/CompactNumericSpinBox.h
+19
View File
@@ -0,0 +1,19 @@
#pragma once
#include <QDoubleSpinBox>
#include <QSpinBox>
namespace gui {
/// 属性栏用紧凑数值框：固定最大宽度，避免撑开过宽。
class CompactIntSpinBox final : public QSpinBox {
public:
explicit CompactIntSpinBox(QWidget* parent = nullptr, int maxWidthPx = 56);
};
class CompactDoubleSpinBox final : public QDoubleSpinBox {
public:
explicit CompactDoubleSpinBox(QWidget* parent = nullptr, int maxWidthPx = 58);
};
} // namespace gui
client/gui/widgets/PropertyPanelControls.cpp
+82
View File
@@ -0,0 +1,82 @@
#include "widgets/PropertyPanelControls.h"
#include <QFormLayout>
#include <QSizePolicy>
#include <QTextEdit>
#include <QTextOption>
#include <QWidget>
namespace gui {
void polishPropertyStretchyTextField(QWidget* w) {
if (!w) {
return;
}
w->setMinimumWidth(0);
w->setMaximumWidth(QWIDGETSIZE_MAX);
const QSizePolicy sp = w->sizePolicy();
w->setSizePolicy(QSizePolicy::MinimumExpanding, sp.verticalPolicy());
}
void polishPropertyFormLayout(QFormLayout* form) {
if (!form) {
return;
}
form->setContentsMargins(0, 0, 0, 0);
form->setSpacing(6);
form->setHorizontalSpacing(8);
form->setVerticalSpacing(6);
form->setRowWrapPolicy(QFormLayout::WrapAllRows);
form->setLabelAlignment(Qt::AlignLeft | Qt::AlignTop);
form->setFieldGrowthPolicy(QFormLayout::AllNonFixedFieldsGrow);
}
void polishPropertyVBoxLayout(QVBoxLayout* lay) {
if (!lay) {
return;
}
lay->setContentsMargins(0, 0, 0, 0);
lay->setSpacing(8);
}
PropertyPanelLineEdit::PropertyPanelLineEdit(QWidget* parent)
: QLineEdit(parent) {
setObjectName(QStringLiteral("PropertyPanelLineEdit"));
setMinimumWidth(0);
setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
setMaximumHeight(26);
}
PropertyPanelComboBox::PropertyPanelComboBox(QWidget* parent)
: QComboBox(parent) {
setObjectName(QStringLiteral("PropertyPanelComboBox"));
setMinimumWidth(0);
setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
setMaximumHeight(26);
}
PropertyPanelCheckBox::PropertyPanelCheckBox(const QString& text, QWidget* parent)
: QCheckBox(text, parent) {
setObjectName(QStringLiteral("PropertyPanelCheckBox"));
setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
}
PropertyPanelPushButton::PropertyPanelPushButton(const QString& text, QWidget* parent)
: QPushButton(text, parent) {
setObjectName(QStringLiteral("PropertyPanelPushButton"));
setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
setMaximumHeight(26);
}
// TextEdit
PropertyPanelTextEdit::PropertyPanelTextEdit(QWidget* parent)
: QTextEdit(parent) {
setObjectName(QStringLiteral("PropertyPanelTextEdit"));
setMinimumWidth(80);
setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Minimum);
setWordWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
setLineWrapMode(QTextEdit::WidgetWidth);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
}
} // namespace gui
client/gui/widgets/PropertyPanelControls.h
+46
View File
@@ -0,0 +1,46 @@
#pragma once
#include <QCheckBox>
#include <QComboBox>
#include <QFormLayout>
#include <QLineEdit>
#include <QPushButton>
#include <QTextEdit>
#include <QVBoxLayout>
namespace gui {
/// 单行文本/容器：随面板宽度伸缩，不强行指定最小像素宽。
void polishPropertyStretchyTextField(QWidget* w);
/// 紧凑属性表：标签在上、控件在下（默认 ~200px 宽即可完整显示，无并排裁切）。
void polishPropertyFormLayout(QFormLayout* form);
void polishPropertyVBoxLayout(QVBoxLayout* lay);
class PropertyPanelLineEdit final : public QLineEdit {
public:
explicit PropertyPanelLineEdit(QWidget* parent = nullptr);
};
class PropertyPanelComboBox final : public QComboBox {
public:
explicit PropertyPanelComboBox(QWidget* parent = nullptr);
};
class PropertyPanelCheckBox final : public QCheckBox {
public:
explicit PropertyPanelCheckBox(const QString& text, QWidget* parent = nullptr);
};
class PropertyPanelPushButton final : public QPushButton {
public:
explicit PropertyPanelPushButton(const QString& text, QWidget* parent = nullptr);
};
class PropertyPanelTextEdit final : public QTextEdit {
public:
explicit PropertyPanelTextEdit(QWidget* parent = nullptr);
};
} // namespace gui