atdunbg/HelloVulkan
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: ImGui docking Editor + 显示链/帧同步/输入语义重构

Browse Source 
- App/editor: Hierarchy/Inspector/Viewport/Stats 四面板 + DockBuilder 默认布局，main.cpp 瘦身为场景搭建与生命周期
- 显示链: Tonemap→PresentTarget 经 ImGui::Image 呈现（零色偏），backbuffer 仅承载 ImGui；Direct/Viewport 双显示模式 + 面板分辨率上报
- 帧首同步 BeginFrameSync: resize/vsync/尺寸/模式意图统一帧首落定（修描述符悬垂）；修复 vsync 意图未落 swapchain 导致的每帧重建交换链
- 输入: Editor 每帧判定键盘/鼠标归属（打字让位、Viewport hover/focus 放行、Fullscreen 全放行）
- 材质: roughness 独立槽位 + 非 glTF 金属/粗糙贴图映射；透明队列 depthWrite=FALSE + translucent 独立 shader + scratch 清帧
- FBX: 非蒙皮网格烘焙节点链全局变换（Z-up 旋转/单位换算落顶点）
- Hierarchy 行 ImGui ID 以 UUID 作用域（重名不冲突、改名不丢选中）
This commit is contained in:
atdunbg
2026-09-30 00:24:53 +08:00
parent b76922824c
commit dd7c67a116
57 changed files with 3067 additions and 622 deletions
Download Patch File Download Diff File Expand all files Collapse all files
App/main.cpp
+118 -356
View File
@@ -3,12 +3,18 @@
//
// SandboxApp：第一个基于 Application 框架的程序。
//
// main 的全部职责：定义一个 Application 派生类并运行它。
// 窗口、渲染器、事件泵、帧计时、场景容器全部由框架管理；
// 这里只写"程序逻辑"：创建实体、逐帧更新组件、事件响应。
// main 的职责边界：
// - 定义 Application 派生类并运行它
// - "程序逻辑"：场景搭建（实体/组件）、逐帧更新、事件响应、
// 异步环境加载
// - UI 全部委托 App/editor/ 的 docking Editor（本文件不再出现
// 任何 ImGui 控件）
//
// 窗口、渲染器、事件泵、帧计时、场景容器全部由框架管理。
//
#include <Engine/Core/Application.h>
#include <Engine/Core/Window.h> // SetInputCapture（Application.h 只前置声明）
#include <Engine/Core/Log.h>
#include <Engine/Core/Stats.h>
#include <Engine/Core/AsyncTask.h>
@@ -17,37 +23,20 @@
#include <Engine/ECS/Components.h>
#include <Engine/Assets/AssetManager.h>
#include <Engine/Renderer/Renderer.h>
#include <Engine/Renderer/IblGenerator.h>
#include <imgui.h>
#include <Engine/Renderer/Model.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <GLFW/glfw3.h>
#include <atomic>
#include <thread>
#include "Editor.h"
#include "EditorContext.h" // kEnvPaths / kDefaultEnv（与 StatsPanel 共用）
using namespace Engine;
using namespace Engine::ECS;
namespace
{
// 可切换环境（IBL 动态切换演示）：路径 → AssetManager 缓存去重，
// 重复选择同一环境零成本；首选路径触发一次 compute 预积分
constexpr const char* kEnvPaths[] = {
"assets/textures/venice_dawn_1_4k.hdr",
"assets/textures/rooitou_park_4k.hdr",
"assets/textures/pink_sunrise_4k.hdr",
"assets/textures/birchwood_4k.hdr",
};
constexpr const char* kEnvNames[] = {
"Venice Dawn", "Rooitou Park", "Pink Sunrise", "Birchwood",
};
constexpr int kEnvCount = 4;
constexpr int kDefaultEnv = 0;
constexpr const char* kTemplePath = "assets/models/SunTemple/SunTemple.fbx";
class SandboxApp final : public Application
@@ -60,11 +49,6 @@ namespace
~SandboxApp() override
{
// worker 只做 CPU 解码（不碰 Vulkan），在任何 GPU 资源
// 析构之前 join 即安全；派生析构先于基类成员析构执行
if (m_EnvWorker.joinable()) {
m_EnvWorker.join();
}
}
protected:
@@ -73,69 +57,83 @@ namespace
void OnInit() override
{
Scene& scene = GetScene();
Renderer& renderer = GetRenderer();
renderer.SetDisplayMode(kDisplayViewport);
// ImGui 叠加层（框架只做管线桥接，UI 内容全部在这里定义）
// ImGui 叠加层（框架只做管线桥接；UI 内容 = docking Editor）
EnableImGui();
// 默认环境（IBL 四件套）：经资产层加载（compute 预积分，毫秒级），
// 其余环境在 ImGui 里按需 lazy 加载后切换
const auto env = GetAssets().LoadEnvironment(
kEnvPaths[kDefaultEnv]);
if (env.Valid()) {
GetRenderer().SetEnvironment(GetAssets().GetEnvironment(env));
// Editor 注入：引擎门面 + 沙盒能力回调（环境异步切换等）
InitEditor();
SetEnv();
const auto suntemple = GetAssets().LoadModel("assets/models/demo/asset.fbx");
auto entityhandle = scene.CreateEntity("SunTemple");
entityhandle.AddComponent<MeshRendererComponent>(MeshRendererComponent{suntemple});
scene.CreateEntity();
scene.CreateEntity();
scene.CreateEntity();
const auto gun = GetAssets().LoadModel("assets/models/m1911/M1911.fbx");
if (gun.Valid()) {
m_Gun = scene.CreateEntity("M1911");
m_Gun.AddComponent<MeshRendererComponent>(MeshRendererComponent{gun});
m_Gun.AddComponent<AnimationComponent>();
auto& gt = m_Gun.GetComponent<TransformComponent>();
gt.SetPosition(glm::vec3(0.0f, 1.2f, -6.0f));
} else {
ENGINE_WARN("m1911 model not loaded, animation test skipped");
}
// 模型资产（PBR 验证场景：backpack 为旧式贴图资产，
// 退化为电介质因子路径——albedo+normal，metallic=0/roughness=0.5）
const auto model = GetAssets().LoadModel("assets/models/backpack/backpack.obj");
// const auto model = GetAssets().LoadModel("assets/models/pocket_watch_4k.gltf/pocket_watch_4k.gltf");
// 大模型异步加载：assimp 解析在 worker 线程（SunTemple 约 3s），
// 完成后 OnUpdate 收割 → GPU 构建 → 建实体（cm 尺度 → 0.001）
m_TempleTask.Run([] { return Model::ParseFromDisk(kTemplePath); });
m_TempleScale = 0.001f;
/*
const auto gun = GetAssets().LoadModel("assets/models/m1911/M1911.fbx");
if (gun.Valid()) {
m_Gun = scene.CreateEntity("M1911");
m_Gun.AddComponent<MeshRendererComponent>(MeshRendererComponent{gun});
m_Gun.AddComponent<AnimationComponent>();
auto& gt = m_Gun.GetComponent<TransformComponent>();
gt.SetPosition(glm::vec3(0.0f, 1.2f, -6.0f));
} else {
ENGINE_WARN("m1911 model not loaded, animation test skipped");
}
int countSize = 0;
for (int i = 0; i < countSize; i ++)
{
for (int j = 0; j < countSize; j ++)
if (countSize) {
// 模型资产（PBR 验证场景：backpack 为旧式贴图资产，
// 退化为电介质因子路径——albedo+normal，metallic=0/roughness=0.5）
const auto model = GetAssets().LoadModel("assets/models/backpack/backpack.obj");
// const auto model = GetAssets().LoadModel("assets/models/pocket_watch_4k.gltf/pocket_watch_4k.gltf");
for (int i = 0; i < countSize; i ++)
{
auto m = scene.CreateEntity();
m.AddComponent<MeshRendererComponent>(MeshRendererComponent{model});
m.GetComponent<TransformComponent>().SetPosition(glm::vec3{(i - countSize * 0.5) * 2, 0, (j - countSize * 0.5) * 2});
m_Spinners.push_back(m);
for (int j = 0; j < countSize; j ++)
{
auto m = scene.CreateEntity();
m.AddComponent<MeshRendererComponent>(MeshRendererComponent{model});
m.GetComponent<TransformComponent>().SetPosition(glm::vec3{(i - countSize * 0.5) * 2, 0, (j - countSize * 0.5) * 2});
m_Spinners.push_back(m);
}
}
}
// 地面：程序化纯色平面（半边长 15，中心 y=-2）
const auto ground = GetAssets().CreatePlane(15.0f, 140, 140, 145);
// 透明管线验证：两片叠放的半透明平面（前后各一，看混合与排序）
const auto glass1 = GetAssets().CreateTransparentPlane(
2.0f, 80, 180, 255, 110);
const auto glass2 = GetAssets().CreateTransparentPlane(
2.0f, 255, 120, 80, 110);
auto g1 = scene.CreateEntity("GlassNear");
g1.AddComponent<MeshRendererComponent>(MeshRendererComponent{glass1});
g1.GetComponent<TransformComponent>()
.SetPosition(glm::vec3(0.0f, 0.5f, -1.0f));
auto g2 = scene.CreateEntity("GlassFar");
g2.AddComponent<MeshRendererComponent>(MeshRendererComponent{glass2});
g2.GetComponent<TransformComponent>()
.SetPosition(glm::vec3(0.0f, 1.0f, -3.0f));
m_Ground = scene.CreateEntity("Ground");
m_Ground.GetComponent<TransformComponent>()
.SetPosition(glm::vec3(0.0f, -0.5f, 0.0f)); // dirty → 帧循环统一 Compose
m_Ground.AddComponent<MeshRendererComponent>(MeshRendererComponent{ground});
*/
// 相机实体（primary = 当前渲染视角；位姿存实体 Transform）
m_Camera = scene.CreateEntity("MainCamera");
auto& camera = m_Camera.AddComponent<CameraComponent>();
camera.primary = true;
m_Camera.GetComponent<TransformComponent>()
.SetPosition(glm::vec3(0.0f, 0.0f, 7.0f));
.SetPosition(glm::vec3(0.0f, 12.0f, 22.0f));
m_Camera.GetComponent<TransformComponent>()
.SetRotation(glm::vec3(-25.0f, 0.0f, 0.0f));
// 灯光实体（第一个方向光 = 阴影光源）
m_KeyLight = scene.CreateEntity("KeyLight");
@@ -147,6 +145,7 @@ namespace
.castShadow = true,
});
/*
scene.CreateEntity("FillLight")
.AddComponent<LightComponent>(
LightComponent{
@@ -154,7 +153,9 @@ namespace
.direction = glm::vec3(0.5f, -0.5f, 0.3f),
.color = glm::vec4(0.3f, 0.5f, 1.0f, 1.5f)
});
*/
/*
// 点光源（位置 = 实体 Transform，出生即有；无阴影，距离衰减）
auto fire = scene.CreateEntity("FirePitLight");
fire.GetComponent<TransformComponent>().SetPosition(glm::vec3(2.0f, 1.5f, 1.0f));
@@ -173,28 +174,11 @@ namespace
.color = glm::vec4(0.3f, 0.5f, 1.0f, 1.2f), // 冷蓝
.radius = 10.0f,
});
*/
}
void OnUpdate(f32 deltaTime) override
{
// 异步模型收割：解析完成 → GPU 构建 → 建实体
if (m_TempleTask.Done()) {
ParsedModel parsed = m_TempleTask.Take();
const auto ref = GetAssets().LoadModel(kTemplePath,
std::move(parsed));
if (ref.Valid()) {
auto temple = GetScene().CreateEntity("SunTemple");
temple.AddComponent<MeshRendererComponent>(
MeshRendererComponent{ref});
temple.GetComponent<TransformComponent>()
.SetScale(glm::vec3{m_TempleScale});
ENGINE_INFO("[ASYNC] SunTemple ready, entity created");
}
}
// 异步环境加载：每帧收割完成的解码结果
PollEnvironment();
// 暂停时冻结动画时钟（帧历史验证：暂停后 Temporal Diff
// 视图应在 2 帧内整屏变黑；相机移动同样会被 diff 捕捉到）
if (!m_PauseAnim)
@@ -216,268 +200,20 @@ namespace
}
}
// ---- UI（全部委托 docking Editor；本文件零 ImGui 控件）----
void OnImGuiRender() override
{
m_Editor->Draw();
}
// ---- 事件 ----
// ---- 异步环境加载（decode 后台线程 / GPU 生成主线程）----
// decode 占切换耗时大头（4k ≈ 130ms）；worker 只产出纯 CPU
// 像素数据，Vulkan 生成回主线程（设备非线程安全）。
// 同一时刻最多一个 in-flight，忙碌期的新请求记为 pending 接力。
void RequestEnvironment(int idx)
{
if (m_EnvLoadBusy)
{
m_EnvPending = idx;
return;
}
StartEnvDecode(idx);
}
void StartEnvDecode(int idx)
{
m_EnvLoadBusy = true;
m_EnvLoadDone.store(false);
m_EnvLoadingPath = kEnvPaths[idx];
m_EnvWorker = std::thread([this, idx]() {
m_EnvDecoded = IblGenerator::DecodeHdr(kEnvPaths[idx]);
m_EnvLoadDone.store(true); // release：解码结果对主线程可见
});
}
void PollEnvironment()
{
if (!m_EnvLoadBusy || !m_EnvLoadDone.load())
{
return;
}
m_EnvWorker.join(); // join = 同步点，解码结果此后归主线程
m_EnvLoadBusy = false;
if (m_EnvDecoded.Valid())
{
const auto ref = GetAssets().LoadEnvironment(
m_EnvLoadingPath, std::move(m_EnvDecoded));
if (ref.Valid())
{
GetRenderer().SetEnvironment(GetAssets().GetEnvironment(ref));
}
}
m_EnvDecoded = {};
// 忙碌期间的最新请求接力（rapid switch 只保留最终意图）
if (m_EnvPending >= 0)
{
const int next = m_EnvPending;
m_EnvPending = -1;
StartEnvDecode(next);
}
}
// ---- 叠加层 UI（唯一允许出现 ImGui 控件的地方）----
void OnRenderOverlay() override
{
ImGui::Begin("Scene Debug");
auto& renderer = GetRenderer();
// ---- Scene：场景内容（灯/动画） ----
if (ImGui::CollapsingHeader("Scene", ImGuiTreeNodeFlags_DefaultOpen))
{
// 阴影光源（无开关，控件平铺聚拢）
if (auto* light = m_KeyLight.TryGetComponent<LightComponent>())
{
ImGui::Text("Key Light (shadow caster)");
ImGui::SliderFloat3("direction",
&light->direction.x, -1.0f, 1.0f);
ImGui::SliderFloat("intensity", &light->color.a, 0.0f, 20.0f);
if (ImGui::Button("reset"))
{
light->direction = glm::vec3(-0.5f, -0.6f, -0.35f);
light->color.a = 2.0f;
}
}
ImGui::Checkbox("Pause Animation", &m_PauseAnim);
}
// ---- Rendering：渲染管线参数与开关 ----
if (ImGui::CollapsingHeader("Rendering", ImGuiTreeNodeFlags_DefaultOpen))
{
// Tonemap（无开关，平铺）
f32 exposure = renderer.GetExposure();
if (ImGui::SliderFloat("exposure", &exposure, 0.1f, 4.0f))
{
renderer.SetExposure(exposure);
}
bool aces = renderer.GetUseACES();
if (ImGui::Checkbox("ACES", &aces))
{
renderer.SetUseACES(aces);
}
// Bloom：开关即显隐——勾上才显示参数
bool bloom = renderer.GetBloomEnabled();
if (ImGui::Checkbox("Bloom", &bloom))
{
renderer.SetBloomEnabled(bloom);
}
if (bloom)
{
f32 threshold = renderer.GetBloomThreshold();
if (ImGui::SliderFloat("threshold", &threshold, 0.0f, 2.0f))
{
renderer.SetBloomThreshold(threshold);
}
f32 strength = renderer.GetBloomStrength();
if (ImGui::SliderFloat("strength", &strength, 0.0f, 2.0f))
{
renderer.SetBloomStrength(strength);
}
}
// 无参数的纯开关：横排平铺
bool shadows = renderer.GetShadowsEnabled();
if (ImGui::Checkbox("Shadows", &shadows))
{
renderer.SetShadowsEnabled(shadows);
}
ImGui::SameLine();
bool taa = renderer.GetTAAEnabled();
if (ImGui::Checkbox("TAA", &taa))
{
renderer.SetTAAEnabled(taa);
}
ImGui::SameLine();
bool lod = renderer.GetLodEnabled();
if (ImGui::Checkbox("LOD", &lod))
{
renderer.SetLodEnabled(lod); // 关 = 恒绘原网格
}
}
// ---- Environment：IBL 环境 + 调试视图（决定"看什么"） ----
if (ImGui::CollapsingHeader("Environment", ImGuiTreeNodeFlags_DefaultOpen))
{
// 动态环境切换（Assets 层加载 → Renderer 换绑；缓存去重）
ImGui::Text("Environment (IBL)");
bool& DrawSkybox = GetScene().GetSettings().DrawSkybox;
ImGui::Checkbox("DrawSkybox", &DrawSkybox);
if (DrawSkybox)
{
int envIdx = m_EnvIndex;
if (ImGui::Combo("env", &envIdx, kEnvNames, kEnvCount))
{
// 异步：解码后台线程，完成后 OnUpdate 里换绑
m_EnvIndex = envIdx;
RequestEnvironment(envIdx);
}
ImGui::Text(m_EnvLoadBusy ? "(decoding...)" :
"(switch = compute pre-integrate, ms-level)");
// 调试视图：单看某个 pass 的中间输出（类 UE pass debug）
const auto& viewNames = renderer.GetDebugViewNames();
int view = renderer.GetDebugView();
if (ImGui::Combo("Debug View", &view, viewNames.data(),
static_cast<int>(viewNames.size())))
{
renderer.SetDebugView(view);
}
}else
{
ImGui::ColorEdit4("ClearColor", glm::value_ptr(GetScene().GetSettings().ClearColor));
}
}
// ---- GPU Timings：只读遥测（默认折叠，不占面板高度） ----
if (ImGui::CollapsingHeader("GPU Timings"))
{
// Pass 级 GPU 耗时（RG timestamp）
ImGui::Text("instances: %u main / %u shadow",
renderer.GetMainInstanceCount(),
renderer.GetShadowInstanceCount());
if (renderer.GetInstancesTruncated()) {
ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f),
"TRUNCATED: instance buffer full!");
}
const auto& names = renderer.GetPassNames();
const auto& times = renderer.GetPassGpuMs();
for (size_t i = 0; i < names.size() && i < times.size(); ++i)
{
ImGui::Text(" %-12s %.3f ms", names[i].c_str(), times[i]);
}
}
// ---- Frame：帧率控制与显示 ----
if (ImGui::CollapsingHeader("Frame", ImGuiTreeNodeFlags_DefaultOpen))
{
auto& app = *this;
bool vsync = app.GetVSync();
if (ImGui::Checkbox("VSync", &vsync))
{
app.SetVSync(vsync);
if (!vsync)
{
const f32 target = app.GetTargetFps();
app.SetTargetFps(target);
}
}
if (!vsync)
{
f32 target = app.GetTargetFps();
if (ImGui::SliderFloat("target fps", &target, 24.0f, 360.0f, "%.0f"))
{
app.SetTargetFps(target);
}
}
ImGui::Text("fps: %.1f frame: %llu",
1.0f / GetDeltaTime(),
static_cast<unsigned long long>(GetFrameCount()));
}
ImGui::End();
// 自定义重载事件： 重载关闭事件模态框
{
if (m_ShowQuitConfirm)
{
ImGui::OpenPopup("Should quit?");
m_ShowQuitConfirm = false;
}
ImGui::SetNextWindowPos(
ImGui::GetMainViewport()->GetCenter(),
ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
if (ImGui::BeginPopupModal("Should quit?", nullptr,
ImGuiWindowFlags_AlwaysAutoResize))
{
ImGui::TextUnformatted("Quit the application?");
ImGui::Separator();
if (ImGui::Button("Yes", ImVec2(120, 0)))
{
m_QuitConfirmed = true;
ImGui::CloseCurrentPopup();
}
ImGui::SameLine();
if (ImGui::Button("No", ImVec2(120, 0)))
{
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
if (m_QuitConfirmed)
{
m_QuitConfirmed = false;
Close();
}
}
}
void OnWindowClose(const Event& event) override
{
// 退出确认走 Editor 的模态框（ImGui 必须可见才有 UI）
SetImGuiEnabled(true);
m_ShowQuitConfirm = true;
m_Editor->RequestQuit();
}
void OnKeyPress(const Event& event) override
@@ -498,25 +234,51 @@ namespace
ENGINE_INFO("App: window resized to {}x{}", event.width, event.height);
}
void SetEnv(int index = 0) {
// 默认环境（IBL 四件套）：经资产层加载（compute 预积分，毫秒级），
// 其余环境在 Stats 面板里按需 lazy 加载后切换
const auto env = GetAssets().LoadEnvironment(kEnvPaths[index]);
if (env.Valid()) {
GetRenderer().SetEnvironment(GetAssets().GetEnvironment(env));
}
}
private:
bool m_ShowQuitConfirm = false;
bool m_QuitConfirmed = false;
// Editor 注入：门面指针 + 反向能力回调（面板 → 沙盒）
void InitEditor()
{
EditorContext ctx;
ctx.renderer = &GetRenderer();
ctx.scene = &GetScene();
ctx.assets = &GetAssets();
ctx.app = this;
ctx.getEnvIndex = [this] { return m_EnvIndex; };
ctx.setEnvIndex = [this](int index) { m_EnvIndex = index; };
ctx.pauseAnim = &m_PauseAnim;
m_Editor->Init(ctx);
// 输入归属：覆盖 EnableImGui 的全局 WantCapture* 谓词
//（全屏 dock host 让它恒真，输入全死）。改为 Editor 按帧
// 判定——Viewport hover/focus 拥有输入（Hazel/UE 语义）；
// UI 隐藏（反引号）时 Draw 不再执行，直接全放行
GetWindow().SetInputCapture(
[this] { return GetImGuiEnabled() && m_Editor->BlockingKeyboard(); },
[this] { return GetImGuiEnabled() && m_Editor->BlockingMouse(); });
}
private:
std::unique_ptr<Editor> m_Editor = std::make_unique<Editor>();
EntityHandle m_Camera{}; // Scene::CreateEntity 之前为空
EntityHandle m_Ground{};
EntityHandle m_KeyLight{};
EntityHandle m_Ground{};
EntityHandle m_Gun{}; // 骨骼动画验证实体（M1911）
std::vector<EntityHandle> m_Spinners;
f32 m_Time = 0.0f;
bool m_PauseAnim = true; // 冻结动画时钟（帧历史 diff 验证用）
bool m_PauseAnim = true; // 冻结动画时钟（Editor 面板可开关）
int m_EnvIndex = kDefaultEnv;
// ---- 异步环境加载状态（单 in-flight + pending 接力）----
std::thread m_EnvWorker;
std::string m_EnvLoadingPath;
DecodedEquirect m_EnvDecoded; // worker 写 → join 后主线程读
std::atomic<bool> m_EnvLoadDone{false};
bool m_EnvLoadBusy = false;
int m_EnvPending = -1;
// ---- 异步模型加载（SunTemple）----
AsyncTask<ParsedModel> m_TempleTask;
f32 m_TempleScale = 1.0f; // cm 尺度资产 → 米（解析后应用）