feat: HitProxy GPU 拾取 + UE 选中描边 + 编辑器拾取交互

- HitProxy 拾取：RG 管线渲染实体 id → host readback，点击帧
  PickEntity 精确命中；拾取按视觉几何（Model 联合包围球射线求交），
  与 Collider 解耦（UE/Unity 编辑器语义），命中打印实体名+碰撞体参数
- 选中描边（UE 语义）：SelectionMask pass（R8Unorm 完整投影轮廓，
  无深度测试透墙可见）→ Outline pass（边缘检测 + alpha 叠加，
  必须注册在 Tonemap 后）；edgeCut 贴视口边缘；widthPx=6 可调
- shader object 实证修复：VUID-08879 同程序 set layouts 超集一致、
  VUID-10065 push block 4×float 平铺、新 pass 析构销毁 VkShaderEXT
- RG：SideEffect() 保活"产出无 RG 内消费者"的 pass 链
- Editor：层次面板点击选中、Inspector 姿态编辑、Stats 面板拾取信息
- 相机 Update 改 const（姿态写入 Transform 引用，Camera 本身无状态变更）

Engine/src/RenderGraph/RenderGraph.cpp

@@ -729,6 +729,7 @@ namespace Engine::RG {
         // 时间戳（BOTTOM_OF_PIPE），索引按执行序排布
         u32 tsPos = 0;
         if (m_QueryPool) {
+            m_WrittenQueries[frame.frameSlot] = 0;   // 上轮残留清零
             frame.cmd.resetQueryPool(m_QueryPool,
                                      frame.frameSlot * m_QueriesPerFrame,
                                      m_QueriesPerFrame);
@@ -820,6 +821,12 @@ namespace Engine::RG {
             ++tsPos;
         }
 
+        // 记录本槽位实际写入的查询数：读侧（Renderer::ReadGpuTimes）按此
+        // 数取结果——被剔除 pass 的时间戳永远不写，按满额阻塞读会死锁
+        if (m_QueryPool) {
+            m_WrittenQueries[frame.frameSlot] = tsPos * 2;
+        }
+
         // 帧尾收集：profiler 在当帧 cmd 内解析查询并上报（提交前录制）
         if (m_GpuProfiler) {
             m_GpuProfiler->EndFrame(frame.cmd);

Engine/src/Renderer/Camera.cpp

@@ -12,8 +12,7 @@
 
 namespace Engine {
 
-    void Camera::Update(Window& window, ECS::TransformComponent& t, f32 deltaTime)
-    {
+    void Camera::Update(Window& window, ECS::TransformComponent& transform, const f32 deltaTime) const {
         // 鼠标视角（编辑器习惯）：按住右键捕获光标进入自由视角，
         // 松开释放光标（ImGui 面板可正常交互）。m_MouseLookEnabled 总开关
         const bool wantLook = m_MouseLookEnabled &&
@@ -30,14 +29,14 @@ namespace Engine {
 
             if (mouseDX != 0 || mouseDY != 0)
             {
-                glm::vec3 rot = t.GetRotation();
+                glm::vec3 rot = transform.GetRotation();
                 // 右手系绕 Y 正角度 = 向左转，鼠标右移（DX>0）应看向右
                 // → yaw 取负。pitch 正角度 = 抬头，鼠标下移（DY>0）低头
                 // → rot.x 直接用负号，两者符号已核对一致
                 rot.y -= mouseDX * m_MouseSensitivity;
                 rot.x = glm::clamp(
                     rot.x - mouseDY * m_MouseSensitivity, -89.0f, 89.0f);
-                t.SetRotation(rot);
+                transform.SetRotation(rot);
             }
         }
         else if (window.IsCursorCaptured())
@@ -47,7 +46,7 @@ namespace Engine {
 
         // 基向量由实体旋转决定（本地 -Z 为视线方向；应用顺序 Y→X，
         // 与 TransformComponent::Compose 一致；roll 不参与 FPS 相机）
-        const glm::vec3& rot = t.GetRotation();
+        const glm::vec3& rot = transform.GetRotation();
         const glm::mat3 r = static_cast<glm::mat3>(
             glm::rotate(glm::mat4(1.0f), glm::radians(rot.y),
                         glm::vec3(0, 1, 0)) *
@@ -56,13 +55,13 @@ namespace Engine {
         const glm::vec3 forward = r * glm::vec3(0, 0, -1);
         const glm::vec3 right   = r * glm::vec3(1, 0, 0);
 
-        f32 speed = m_MoveSpeed * deltaTime;
-        if (window.IsKeyPressed(GLFW_KEY_W)) { t.SetPosition(t.GetPosition() + forward * speed); }
-        if (window.IsKeyPressed(GLFW_KEY_S)) { t.SetPosition(t.GetPosition() - forward * speed); }
-        if (window.IsKeyPressed(GLFW_KEY_A)) { t.SetPosition(t.GetPosition() - right * speed); }
-        if (window.IsKeyPressed(GLFW_KEY_D)) { t.SetPosition(t.GetPosition() + right * speed); }
-        if (window.IsKeyPressed(GLFW_KEY_SPACE)) { t.SetPosition(t.GetPosition() + glm::vec3(0, speed, 0)); }
-        if (window.IsKeyPressed(GLFW_KEY_LEFT_SHIFT)) { t.SetPosition(t.GetPosition() - glm::vec3(0, speed, 0)); }
+        const f32 speed = m_MoveSpeed * deltaTime;
+        if (window.IsKeyPressed(GLFW_KEY_W)) { transform.SetPosition(transform.GetPosition() + forward * speed); }
+        if (window.IsKeyPressed(GLFW_KEY_S)) { transform.SetPosition(transform.GetPosition() - forward * speed); }
+        if (window.IsKeyPressed(GLFW_KEY_A)) { transform.SetPosition(transform.GetPosition() - right * speed); }
+        if (window.IsKeyPressed(GLFW_KEY_D)) { transform.SetPosition(transform.GetPosition() + right * speed); }
+        if (window.IsKeyPressed(GLFW_KEY_SPACE)) { transform.SetPosition(transform.GetPosition() + glm::vec3(0, speed, 0)); }
+        if (window.IsKeyPressed(GLFW_KEY_LEFT_SHIFT)) { transform.SetPosition(transform.GetPosition() - glm::vec3(0, speed, 0)); }
     }
 
     glm::mat4 Camera::GetView(const ECS::TransformComponent& t) const
@@ -71,7 +70,7 @@ namespace Engine {
         return glm::inverse(t.World());
     }
 
-    glm::mat4 Camera::GetProjection(f32 aspect, f32 nearZ, f32 farZ) const
+    glm::mat4 Camera::GetProjection(const f32 aspect, const f32 nearZ, const f32 farZ) const
     {
         auto proj = glm::perspective(glm::radians(45.0f), aspect, nearZ, farZ);
         proj[1][1] *= -1.0f; // Vulkan Y 翻转

Engine/src/Renderer/Passes/HitProxyPass.cpp

@@ -0,0 +1,246 @@
+//
+// HitProxyPass.cpp：pass 装配（shader object + 暂存 buffer）与录制。
+//
+// 拾取管线与 Forward 同构（Set0 描述符、顶点输入、MDI batch 结构全部
+// 复用），差异只有：R32Uint 目标、无光照 id 片元、深度重清自写。
+//
+
+#include <Engine/Renderer/Passes/HitProxyPass.h>
+#include <Engine/Renderer/Passes/SceneGpu.h>
+#include <Engine/Renderer/Vertex.h>
+#include <Engine/Renderer/Mesh.h>          // batch.mesh->Draw（完整类型）
+#include <Engine/Vulkan/Device.h>
+#include <Engine/Vulkan/DescriptorManager.h>
+#include <Engine/Vulkan/ShaderManager.h>
+#include <Engine/Core/Log.h>
+
+#include <glm/glm.hpp>
+#include <tracy/Tracy.hpp>
+#include <algorithm>
+#include <array>
+#include <cstring>
+
+namespace Engine::Passes
+{
+    namespace
+    {
+        // 直写方程：(ONE, ZERO) → dst = src，数学上等价于无混合
+        vk::ColorBlendEquationEXT MakeDirectEquation()
+        {
+            vk::ColorBlendEquationEXT eq;
+            eq.setSrcColorBlendFactor(vk::BlendFactor::eOne)
+              .setDstColorBlendFactor(vk::BlendFactor::eZero)
+              .setColorBlendOp(vk::BlendOp::eAdd)
+              .setSrcAlphaBlendFactor(vk::BlendFactor::eOne)
+              .setDstAlphaBlendFactor(vk::BlendFactor::eZero)
+              .setAlphaBlendOp(vk::BlendOp::eAdd);
+            return eq;
+        }
+
+        constexpr vk::ColorComponentFlags kColorWriteMask =
+            vk::ColorComponentFlagBits::eR |
+            vk::ColorComponentFlagBits::eG |
+            vk::ColorComponentFlagBits::eB |
+            vk::ColorComponentFlagBits::eA;
+    } // namespace
+
+    HitProxyPass::HitProxyPass(Device& device, MemoryAllocator& allocator,
+                               ShaderManager& shaders,
+                               DescriptorManager& descriptors,
+                               SceneGpu& gpu, FrameSceneData& frame,
+                               RG::TextureHandle idTarget,
+                               RG::TextureHandle depth)
+        : m_Device(device), m_Gpu(gpu), m_Frame(frame),
+          m_IdTarget(idTarget), m_Depth(depth)
+    {
+        // Set0 = uboSetLayout（UBO + 实例矩阵 + 蒙皮 + 实体 id），无 push
+        m_Layout = descriptors.CreatePipelineLayout(
+            std::vector<vk::DescriptorSetLayout>{gpu.uboSetLayout}, 0);
+
+        const std::string shaderDir = "shaders/";
+        auto vert = shaders.CreateFromFile(
+            shaderDir + "hitproxy.vert.spv",
+            vk::ShaderStageFlagBits::eVertex,
+            std::vector<vk::DescriptorSetLayout>{gpu.uboSetLayout}, 0);
+        auto frag = shaders.CreateFromFile(
+            shaderDir + "hitproxy.frag.spv",
+            vk::ShaderStageFlagBits::eFragment,
+            std::vector<vk::DescriptorSetLayout>{gpu.uboSetLayout}, 0);
+
+        m_Vert = vert.Handle;
+        m_Frag = frag.Handle;
+        if (!m_Vert || !m_Frag) {
+            ENGINE_FATAL("HitProxyPass: failed to create shader objects");
+        }
+
+        // 1×1 像素暂存（256B 对齐 minMemoryMapAlignment 余量），持久映射
+        m_Staging = CreateScope<Buffer>(
+            device, allocator, 256,
+            vk::BufferUsageFlagBits::eTransferDst,
+            vk::MemoryPropertyFlagBits::eHostVisible |
+                vk::MemoryPropertyFlagBits::eHostCoherent);
+    }
+
+    HitProxyPass::~HitProxyPass()
+    {
+        const auto& vkDevice = m_Device.GetDevice();
+
+        if (m_Vert) vkDevice.destroyShaderEXT(m_Vert);
+        if (m_Frag) vkDevice.destroyShaderEXT(m_Frag);
+        vkDevice.destroyPipelineLayout(m_Layout);
+    }
+
+    bool HitProxyPass::TakeResult(u32& outBits)
+    {
+        if (!m_ResultValid || !m_Staging || !m_Staging->MappedPtr()) {
+            return false;
+        }
+        m_ResultValid = false;
+        std::memcpy(&outBits, m_Staging->MappedPtr(), sizeof(u32));
+        return true;
+    }
+
+    void HitProxyPass::Register(RG::RenderGraph& rg)
+    {
+        // ---- id 渲染：拾取请求帧才绘制（无请求帧零 GPU 开销）----
+        rg.AddPass("HitProxy", [this](RG::RenderGraphContext& ctx) {
+            if (!m_Frame.pickRequest.active) return;
+
+            ZoneScopedN("HitProxy");
+            const vk::CommandBuffer cmd = ctx.cmd;
+
+            // id 目标清 kPickMiss（天空/空隙 = 未命中；0xFFFFFFFF 永不
+            // 与有效实体冲突）
+            vk::ClearValue idClear;
+            idClear.color = vk::ClearColorValue(
+                std::array<u32, 4>{kPickMiss, kPickMiss, kPickMiss, kPickMiss});
+
+            vk::RenderingAttachmentInfo color;
+            color.setImageView(ctx.View(m_IdTarget))
+                 .setImageLayout(vk::ImageLayout::eColorAttachmentOptimal)
+                 .setLoadOp(vk::AttachmentLoadOp::eClear)
+                 .setStoreOp(vk::AttachmentStoreOp::eStore)
+                 .setClearValue(idClear);
+
+            // 主深度重清自写：拾取遮挡 = 本 pass 内深度解算，最近表面
+            // 胜出。本 pass 是深度 WAW 链尾，主链下游无人再读深度
+            vk::RenderingAttachmentInfo depth;
+            depth.setImageView(ctx.View(m_Depth))
+                 .setImageLayout(vk::ImageLayout::eDepthAttachmentOptimal)
+                 .setLoadOp(vk::AttachmentLoadOp::eClear)
+                 .setStoreOp(vk::AttachmentStoreOp::eDontCare)
+                 .setClearValue(
+                     vk::ClearValue(vk::ClearDepthStencilValue(1.0f, 0)));
+
+            vk::RenderingInfo renderingInfo;
+            renderingInfo.setRenderArea({{0, 0}, ctx.extent})
+                         .setLayerCount(1)
+                         .setColorAttachments(color)
+                         .setPDepthAttachment(&depth);
+
+            cmd.beginRendering(renderingInfo);
+
+            const std::array<vk::ShaderStageFlagBits, 2> stages = {
+                vk::ShaderStageFlagBits::eVertex,
+                vk::ShaderStageFlagBits::eFragment};
+            const std::array<vk::ShaderEXT, 2> shaders = {m_Vert, m_Frag};
+            cmd.bindShadersEXT(stages, shaders);
+
+            // Set0 = uboSets（UBO + 实例矩阵 + 蒙皮 + 实体 id）
+            cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
+                                   m_Layout, 0,
+                                   m_Gpu.uboSets[ctx.frame.frameSlot], {});
+
+            // ---- 动态状态（shader object 无管线对象，全量显式设置）----
+            cmd.setRasterizerDiscardEnable(VK_FALSE);
+
+            cmd.setDepthTestEnable(VK_TRUE);
+            cmd.setDepthCompareOp(vk::CompareOp::eLess);
+            cmd.setDepthWriteEnable(VK_TRUE);
+            cmd.setDepthBoundsTestEnable(VK_FALSE);
+            cmd.setStencilTestEnable(VK_FALSE);
+            cmd.setDepthBiasEnable(VK_FALSE);
+
+            cmd.setPolygonModeEXT(vk::PolygonMode::eFill);
+            cmd.setCullMode(vk::CullModeFlagBits::eNone);
+            cmd.setFrontFace(vk::FrontFace::eCounterClockwise);
+            cmd.setPrimitiveTopology(vk::PrimitiveTopology::eTriangleList);
+            cmd.setPrimitiveRestartEnable(VK_FALSE);
+
+            const auto binding = Vertex::GetBindingDescription();
+            const auto attributes = Vertex::GetAttributeDescriptions();
+            cmd.setVertexInputEXT(binding, attributes);
+
+            cmd.setRasterizationSamplesEXT(vk::SampleCountFlagBits::e1);
+            constexpr vk::SampleMask sampleMask = 0xFFFFFFFF;
+            cmd.setSampleMaskEXT(vk::SampleCountFlagBits::e1, sampleMask);
+            cmd.setAlphaToCoverageEnableEXT(VK_FALSE);
+            cmd.setAlphaToOneEnableEXT(VK_FALSE);
+
+            const vk::Viewport viewport(
+                0.0f, 0.0f, static_cast<f32>(ctx.extent.width),
+                static_cast<f32>(ctx.extent.height), 0.0f, 1.0f);
+            cmd.setViewportWithCount(viewport);
+            cmd.setScissorWithCount(vk::Rect2D({0, 0}, ctx.extent));
+
+            // 无混合直写（id 是整数载荷，混合无意义）
+            constexpr vk::Bool32 blendEnable = VK_FALSE;
+            const vk::ColorBlendEquationEXT direct = MakeDirectEquation();
+            cmd.setColorBlendEnableEXT(0, blendEnable);
+            cmd.setColorBlendEquationEXT(0, direct);
+            cmd.setColorWriteMaskEXT(0, kColorWriteMask);
+
+            // 不透明 + 透明 batch 全画：id 语义下透明按不透明处理
+            //（玻璃可拾取且遮挡其后图元，与 UE HitProxy 一致）
+            for (const auto& batch : m_Frame.mainView.batches) {
+                batch.mesh->Draw(cmd, batch.count, batch.first, batch.lod);
+            }
+            for (const auto& batch : m_Frame.translucentView.batches) {
+                batch.mesh->Draw(cmd, batch.count, batch.first, batch.lod);
+            }
+
+            cmd.endRendering();
+        })
+        .Write(m_IdTarget, RG::ResourceUse::ColorAttachment)
+        .Write(m_Depth, RG::ResourceUse::DepthAttachment)
+        // 拷贝终点是 RG 外的 host 暂存 buffer：从数据流视角 idTarget
+        // 无 RG 内消费者，两 pass 会被引用计数剔除——显式保活
+        .SideEffect();
+
+        // ---- 像素拷贝：请求像素 1×1 → host 暂存。TransferSrc use 让
+        // RG 自动做 eColorAttachmentOptimal → eTransferSrcOptimal 迁移
+        //（RAW 边保证排在本 pass 的 id 写入之后）----
+        rg.AddPass("HitProxyCopy", [this](RG::RenderGraphContext& ctx) {
+            if (!m_Frame.pickRequest.active) return;
+
+            const vk::CommandBuffer cmd = ctx.cmd;
+
+            // NDC → 请求像素（钳到目标内，防面板边缘点击越界）
+            const vk::Extent2D ext = ctx.Extent(m_IdTarget);
+            const i32 px = std::clamp(
+                static_cast<i32>((m_Frame.pickRequest.ndc.x * 0.5f + 0.5f) *
+                                 static_cast<f32>(ext.width)),
+                0, static_cast<i32>(ext.width) - 1);
+            const i32 py = std::clamp(
+                static_cast<i32>((m_Frame.pickRequest.ndc.y * 0.5f + 0.5f) *
+                                 static_cast<f32>(ext.height)),
+                0, static_cast<i32>(ext.height) - 1);
+
+            vk::BufferImageCopy region;
+            region.setImageSubresource(vk::ImageSubresourceLayers(
+                                       vk::ImageAspectFlagBits::eColor,
+                                       0, 0, 1))
+                       .setImageOffset(vk::Offset3D(px, py, 0))
+                       .setImageExtent(vk::Extent3D(1, 1, 1));
+
+            cmd.copyImageToBuffer(
+                ctx.Image(m_IdTarget), vk::ImageLayout::eTransferSrcOptimal,
+                m_Staging->Get(), region);
+
+            m_ResultValid = true;   // 拷贝已录制：结果可待取
+        })
+        .Read(m_IdTarget, RG::ResourceUse::TransferSrc)
+        .SideEffect();
+    }
+
+} // namespace Engine::Passes

Engine/src/Renderer/Passes/OutlinePass.cpp

@@ -0,0 +1,142 @@
+//
+// OutlinePass.cpp：pass 装配与录制（见头文件注释）。
+//
+// 录制段复制 FullscreenGpu::RecordFullscreen 的动态状态骨架，仅两处
+// 不同：颜色混合改为 alpha 叠加（其余像素 alpha=0 不改画面）、
+// PresentTarget 附件 loadOp=eLoad（保留 Tonemap 输出）。
+//
+
+#include <Engine/Renderer/Passes/OutlinePass.h>
+#include <Engine/Renderer/Passes/FullscreenGpu.h>
+#include <Engine/Vulkan/ShaderManager.h>
+#include <Engine/Vulkan/Device.h>
+#include <Engine/Core/FrameContext.h>
+
+#include <glm/glm.hpp>
+
+#include <array>
+
+namespace Engine::Passes
+{
+    OutlinePass::OutlinePass(Device& device, FullscreenGpu& gpu, ShaderManager& shaders,
+                             FrameSceneData& frame,
+                             RG::TextureHandle mask, RG::TextureHandle present,
+                             const glm::vec3& color, f32 widthPx)
+        : m_Device(device), m_Gpu(gpu), m_Frame(frame), m_Mask(mask), m_Present(present),
+          m_Color(color), m_WidthPx(widthPx)    {
+        m_Frag = shaders.CreateFromFile(
+            "shaders/outline.frag.spv",
+            vk::ShaderStageFlagBits::eFragment,
+            std::vector<vk::DescriptorSetLayout>{gpu.setLayout},
+            sizeof(FullscreenPush));
+
+        m_Sets.resize(kMaxFramesInFlight);
+        for (u32 slot = 0; slot < kMaxFramesInFlight; ++slot) {
+            m_Sets[slot] = m_Gpu.AllocateSet();
+        }
+    }
+
+    OutlinePass::~OutlinePass()
+    {
+        // VkShaderEXT 是 Device 子对象，必须在 vkDestroyDevice 前销毁
+        if (m_Frag.Handle) m_Device.GetDevice().destroyShaderEXT(m_Frag.Handle);
+    }
+
+    void OutlinePass::Register(RG::RenderGraph& rg)
+    {
+        rg.AddPass("Outline", [this](RG::RenderGraphContext& ctx) {
+            // 无选中零 GPU（mask 已由 SelectionMask pass 清 0，无描边）
+            if (m_Frame.selectedEntityBits == 0) return;
+
+            const vk::CommandBuffer cmd = ctx.cmd;
+
+            // PresentTarget：eLoad 保留 Tonemap 输出，只叠加描边
+            vk::RenderingAttachmentInfo colorAttachment;
+            colorAttachment.setImageView(ctx.View(m_Present))
+                           .setImageLayout(vk::ImageLayout::eColorAttachmentOptimal)
+                           .setLoadOp(vk::AttachmentLoadOp::eLoad)
+                           .setStoreOp(vk::AttachmentStoreOp::eStore);
+
+            vk::RenderingInfo renderingInfo;
+            renderingInfo.setRenderArea({{0, 0}, ctx.extent})
+                         .setLayerCount(1)
+                         .setColorAttachments(colorAttachment);
+            cmd.beginRendering(renderingInfo);
+
+            std::array<vk::ShaderStageFlagBits, 2> stages = {
+                vk::ShaderStageFlagBits::eVertex,
+                vk::ShaderStageFlagBits::eFragment};
+            std::array<vk::ShaderEXT, 2> shaders = {m_Gpu.vert, m_Frag.Handle};
+            cmd.bindShadersEXT(stages, shaders);
+
+            cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
+                                   m_Gpu.layout, 0,
+                                   m_Sets[ctx.frame.frameSlot], {});
+
+            cmd.setRasterizerDiscardEnable(VK_FALSE);
+            cmd.setDepthTestEnable(VK_FALSE);
+            cmd.setDepthWriteEnable(VK_FALSE);
+            cmd.setDepthBoundsTestEnable(VK_FALSE);
+            cmd.setStencilTestEnable(VK_FALSE);
+            cmd.setDepthBiasEnable(VK_FALSE);
+            cmd.setPolygonModeEXT(vk::PolygonMode::eFill);
+            cmd.setCullMode(vk::CullModeFlagBits::eNone);
+            cmd.setPrimitiveTopology(vk::PrimitiveTopology::eTriangleList);
+            cmd.setPrimitiveRestartEnable(VK_FALSE);
+
+            cmd.setRasterizationSamplesEXT(vk::SampleCountFlagBits::e1);
+            vk::SampleMask sampleMask = 0xFFFFFFFF;
+            cmd.setSampleMaskEXT(vk::SampleCountFlagBits::e1, sampleMask);
+
+            vk::Viewport viewport(0.0f, 0.0f,
+                                  static_cast<float>(ctx.extent.width),
+                                  static_cast<float>(ctx.extent.height),
+                                  0.0f, 1.0f);
+            cmd.setViewportWithCount(viewport);
+            cmd.setScissorWithCount(vk::Rect2D({0, 0}, ctx.extent));
+
+            // alpha 叠加：描边像素 src 上色，其余（alpha=0）不改画面。
+            // alpha 通道必须保持 dst（Zero,One）——PresentTarget 的
+            // alpha 归 Tonemap/ImGui 链所有：ImGui 后端按 (SRC_ALPHA,
+            // ONE_MINUS_SRC_ALPHA) 混合，若把 alpha 覆写成 0，视口图
+            // 整体被乘 0 = 黑屏（只有描边像素 alpha=1 可见）
+            cmd.setColorBlendEnableEXT(0, VK_TRUE);
+            vk::ColorBlendEquationEXT blend;
+            blend.setSrcColorBlendFactor(vk::BlendFactor::eSrcAlpha)
+                 .setDstColorBlendFactor(vk::BlendFactor::eOneMinusSrcAlpha)
+                 .setColorBlendOp(vk::BlendOp::eAdd)
+                 .setSrcAlphaBlendFactor(vk::BlendFactor::eZero)
+                 .setDstAlphaBlendFactor(vk::BlendFactor::eOne)
+                 .setAlphaBlendOp(vk::BlendOp::eAdd);
+            cmd.setColorBlendEquationEXT(0, blend);
+            cmd.setColorWriteMaskEXT(0,
+                vk::ColorComponentFlagBits::eR |
+                vk::ColorComponentFlagBits::eG |
+                vk::ColorComponentFlagBits::eB |
+                vk::ColorComponentFlagBits::eA);
+
+            // 复用全屏 push（16B）：exposure 槽位=宽度，param0-2=描边色
+            const FullscreenPush push{m_WidthPx, m_Color.r, m_Color.g, m_Color.b};
+            cmd.pushConstants(m_Gpu.layout,
+                              vk::ShaderStageFlagBits::eVertex |
+                              vk::ShaderStageFlagBits::eFragment,
+                              0, sizeof(FullscreenPush), &push);
+
+            cmd.draw(3, 1, 0, 0);
+            cmd.endRendering();
+        })
+        .Write(m_Present, RG::ResourceUse::ColorAttachment)
+        .Read(m_Mask, RG::ResourceUse::ShaderRead,
+              vk::ShaderStageFlagBits::eFragment)
+        // 无选中帧跳过绘制：显式保活（HitProxy 教训）
+        .SideEffect();
+    }
+
+    void OutlinePass::OnTargetsRebuilt(RG::RenderGraph& rg)
+    {
+        for (u32 slot = 0; slot < kMaxFramesInFlight; ++slot) {
+            m_Gpu.UpdateSetInput(m_Sets[slot], 0, rg, m_Mask, slot);
+        }
+    }
+
+} // namespace Engine::Passes

Engine/src/Renderer/Passes/SceneGpu.cpp

@@ -23,12 +23,14 @@ namespace Engine::Passes
                        UniformBuffer& ubo, UniformBuffer& objectBuffer,
                        UniformBuffer& prevObjectBuffer,
                        UniformBuffer& skinOffsetBuffer,
-                       UniformBuffer& skinPaletteBuffer)
+                       UniformBuffer& skinPaletteBuffer,
+                       UniformBuffer& entityIdBuffer)
         : m_Device(device), m_Allocator(allocator), m_Descriptors(descriptors)
     {
         // Set 0: UBO + GPUDriven 实例数据（SSBO，vertex 读取）
         // + 上一帧实例矩阵（TAA velocity，vertex 读取）
         // + 骨骼蒙皮：SkinOffsets（实例→palette 基址）+ SkinPalettes（骨骼矩阵）
+        // + EntityIds（实例→实体位模式，HitProxy 拾取）
         std::vector<DescriptorBinding> uboBindings = {
             {0, vk::DescriptorType::eUniformBuffer,
              vk::ShaderStageFlagBits::eVertex | vk::ShaderStageFlagBits::eFragment},
@@ -40,6 +42,8 @@ namespace Engine::Passes
              vk::ShaderStageFlagBits::eVertex},
             {4, vk::DescriptorType::eStorageBuffer,
              vk::ShaderStageFlagBits::eVertex},
+            {5, vk::DescriptorType::eStorageBuffer,
+             vk::ShaderStageFlagBits::eVertex},
         };
         uboSetLayout = descriptors.CreateLayout(uboBindings);
 
@@ -155,6 +159,9 @@ namespace Engine::Passes
             descriptors.UpdateStorageBuffer(
                 uboSets[slot], 4, skinPaletteBuffer.Get(slot),
                 skinPaletteBuffer.GetSize());
+            descriptors.UpdateStorageBuffer(
+                uboSets[slot], 5, entityIdBuffer.Get(slot),
+                entityIdBuffer.GetSize());
 
             shadowSets[slot] = descriptors.AllocateDescriptorSet(shadowSetLayout);
         }

Engine/src/Renderer/Passes/SelectionMaskPass.cpp

@@ -0,0 +1,138 @@
+//
+// SelectionMaskPass.cpp：pass 装配与录制（见头文件注释）。
+//
+
+#include <Engine/Renderer/Passes/SelectionMaskPass.h>
+#include <Engine/Renderer/Passes/SceneGpu.h>
+#include <Engine/Vulkan/ShaderManager.h>
+#include <Engine/Vulkan/Device.h>
+#include <Engine/Renderer/Vertex.h>
+#include <Engine/Renderer/Mesh.h>
+
+#include <array>
+
+namespace Engine::Passes
+{
+    SelectionMaskPass::SelectionMaskPass(Device& device, ShaderManager& shaders,
+                                         SceneGpu& gpu, FrameSceneData& frame,
+                                         RG::TextureHandle mask)
+        : m_Device(device), m_Gpu(gpu), m_Frame(frame), m_Mask(mask)
+    {
+        // 恒 1 片元；布局数组必须与 forwardVert 完全一致（shader object
+        // 要求同程序各 shader 的 set layouts 逐项相同，VUID-08879），
+        // 本 shader 只用 Set0，多声明是合法超集
+        m_Frag = shaders.CreateFromFile(
+            "shaders/sel_mask.frag.spv",
+            vk::ShaderStageFlagBits::eFragment,
+            std::vector<vk::DescriptorSetLayout>{
+                gpu.uboSetLayout, gpu.textureSetLayout, gpu.shadowSetLayout},
+            0);
+    }
+
+    SelectionMaskPass::~SelectionMaskPass()
+    {
+        // VkShaderEXT 是 Device 子对象，必须在 vkDestroyDevice 前销毁
+        if (m_Frag.Handle) m_Device.GetDevice().destroyShaderEXT(m_Frag.Handle);
+    }
+
+    void SelectionMaskPass::Register(RG::RenderGraph& rg)
+    {
+        rg.AddPass("SelectionMask", [this](RG::RenderGraphContext& ctx) {
+            const vk::CommandBuffer cmd = ctx.cmd;
+            const bool hasDraws = !m_Frame.selectionDraws.empty();
+
+            // mask 附件：每帧清 0（无选中帧残留自动消失）
+            vk::ClearValue maskClear;
+            maskClear.color = vk::ClearColorValue(std::array<float, 4>{0.f, 0.f, 0.f, 0.f});
+            vk::RenderingAttachmentInfo colorAttachment;
+            colorAttachment.setImageView(ctx.View(m_Mask))
+                           .setImageLayout(vk::ImageLayout::eColorAttachmentOptimal)
+                           .setLoadOp(vk::AttachmentLoadOp::eClear)
+                           .setStoreOp(vk::AttachmentStoreOp::eStore)
+                           .setClearValue(maskClear);
+
+            // 无深度附件——mask = 选中实体完整投影轮廓（不做遮挡判定，
+            // UE 编辑器选中轮廓透墙可见同语义）。若做深度测试，前方
+            // 遮挡物会在 mask 上挖洞，边缘检测会把洞的轮廓也描出来
+            // （表现为"选地面却给枪描了边"）。
+            vk::RenderingInfo renderingInfo;
+            renderingInfo.setRenderArea({{0, 0}, ctx.extent})
+                         .setLayerCount(1)
+                         .setColorAttachments(colorAttachment);
+            cmd.beginRendering(renderingInfo);
+
+            if (hasDraws) {
+                // 复用 Forward 顶点着色（静态/蒙皮同源变换）+ 恒 1 片元
+                std::array<vk::ShaderStageFlagBits, 2> stages = {
+                    vk::ShaderStageFlagBits::eVertex,
+                    vk::ShaderStageFlagBits::eFragment};
+                std::array<vk::ShaderEXT, 2> shaders = {m_Gpu.forwardVert,
+                                                        m_Frag.Handle};
+                cmd.bindShadersEXT(stages, shaders);
+
+                // Set0：本帧槽位 UBO + 实例/蒙皮 SSBO（Set1 材质、Set2
+                // 阴影不采样不绑，合法）
+                cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics,
+                                       m_Gpu.forwardLayout, 0,
+                                       m_Gpu.uboSets[ctx.frame.frameSlot], {});
+
+                // ---- 动态状态（与 Forward 对齐，无深度测试）----
+                cmd.setRasterizerDiscardEnable(VK_FALSE);
+                cmd.setDepthTestEnable(VK_FALSE);
+                cmd.setDepthWriteEnable(VK_FALSE);
+                cmd.setDepthBoundsTestEnable(VK_FALSE);
+                cmd.setStencilTestEnable(VK_FALSE);
+                cmd.setDepthBiasEnable(VK_FALSE);
+                cmd.setPolygonModeEXT(vk::PolygonMode::eFill);
+                cmd.setCullMode(vk::CullModeFlagBits::eNone);
+                cmd.setFrontFace(vk::FrontFace::eCounterClockwise);
+                cmd.setPrimitiveTopology(vk::PrimitiveTopology::eTriangleList);
+                cmd.setPrimitiveRestartEnable(VK_FALSE);
+
+                cmd.setVertexInputEXT(Vertex::GetBindingDescription(),
+                                      Vertex::GetAttributeDescriptions());
+
+                cmd.setRasterizationSamplesEXT(vk::SampleCountFlagBits::e1);
+                vk::SampleMask sampleMask = 0xFFFFFFFF;
+                cmd.setSampleMaskEXT(vk::SampleCountFlagBits::e1, sampleMask);
+                cmd.setAlphaToCoverageEnableEXT(VK_FALSE);
+                cmd.setAlphaToOneEnableEXT(VK_FALSE);
+
+                vk::Viewport viewport(0.0f, 0.0f,
+                                      static_cast<float>(ctx.extent.width),
+                                      static_cast<float>(ctx.extent.height),
+                                      0.0f, 1.0f);
+                cmd.setViewportWithCount(viewport);
+                cmd.setScissorWithCount(vk::Rect2D({0, 0}, ctx.extent));
+
+                // 无混合直写（mask 任何非零 = 选中）
+                cmd.setColorBlendEnableEXT(0, VK_FALSE);
+                vk::ColorBlendEquationEXT direct;
+                direct.setSrcColorBlendFactor(vk::BlendFactor::eOne)
+                      .setDstColorBlendFactor(vk::BlendFactor::eZero)
+                      .setColorBlendOp(vk::BlendOp::eAdd)
+                      .setSrcAlphaBlendFactor(vk::BlendFactor::eOne)
+                      .setDstAlphaBlendFactor(vk::BlendFactor::eZero)
+                      .setAlphaBlendOp(vk::BlendOp::eAdd);
+                cmd.setColorBlendEquationEXT(0, direct);
+                cmd.setColorWriteMaskEXT(0,
+                    vk::ColorComponentFlagBits::eR |
+                    vk::ColorComponentFlagBits::eG |
+                    vk::ColorComponentFlagBits::eB |
+                    vk::ColorComponentFlagBits::eA);
+
+                // 逐选中实例绘制（一次一实例，选中开销可忽略）
+                for (const auto& d : m_Frame.selectionDraws) {
+                    d.mesh->Draw(cmd, 1, d.instance, d.lod);
+                }
+            }
+
+            cmd.endRendering();
+        })
+        .Write(m_Mask, RG::ResourceUse::ColorAttachment)
+        // 无选中帧只 clear 不绘制：显式保活，否则整条描边链被
+        // 引用计数剔除（HitProxy 教训）
+        .SideEffect();
+    }
+
+} // namespace Engine::Passes

Engine/src/Renderer/Renderer.cpp

@@ -15,6 +15,11 @@
 #include <Engine/Renderer/Passes/SkyboxPass.h>
 #include <Engine/Renderer/Passes/ShadowPass.h>
 #include <Engine/Renderer/Passes/ForwardPass.h>
+#include <Engine/Renderer/Passes/PhysicsDebugPass.h>
+#include <Engine/Renderer/Passes/HitProxyPass.h>
+#include <Engine/Renderer/Passes/SelectionMaskPass.h>
+#include <Engine/Renderer/Passes/OutlinePass.h>
+#include <Engine/Physics/PhysicsDebugTypes.h>
 #include <Engine/Renderer/Cubemap.h>
 #include <Engine/Renderer/IblGenerator.h>
 #include <Engine/Renderer/TracyGpuProfiler.h>
@@ -80,15 +85,32 @@ namespace Engine
             *m_Device, *m_Allocator,
             sizeof(glm::mat4) * kMaxSkinMatrices, kMaxFramesInFlight,
             vk::BufferUsageFlagBits::eStorageBuffer);
+        m_EntityIdBuffer = CreateScope<UniformBuffer>(
+            *m_Device, *m_Allocator,
+            sizeof(u32) * kMaxInstances, kMaxFramesInFlight,
+            vk::BufferUsageFlagBits::eStorageBuffer);
 
         // 3. pass 装配体：布局/shader/采样器/per-slot 描述符
         m_SceneGpu = CreateScope<Passes::SceneGpu>(
             *m_Device, *m_Allocator, *m_DescriptorManager, *m_ShaderManager,
             *m_UniformBuffer, *m_ObjectBuffer, *m_PrevObjectBuffer,
-            *m_SkinOffsetBuffer, *m_SkinPaletteBuffer);
+            *m_SkinOffsetBuffer, *m_SkinPaletteBuffer, *m_EntityIdBuffer);
         m_FullscreenGpu = CreateScope<Passes::FullscreenGpu>(
             *m_Device, *m_DescriptorManager, *m_ShaderManager);
 
+        // 3.2 物理调试图元 ring VB：eVertexBuffer 用法，复用 UniformBuffer
+        //     的 per-slot fence 语义（PrepareFrame 在 WaitFence 后上传）
+        m_PhysicsLineVB = CreateScope<UniformBuffer>(
+            *m_Device, *m_Allocator,
+            u64(Passes::PhysicsDebugPass::kMaxLineVerts) *
+                sizeof(PhysicsDebugVertex),
+            kMaxFramesInFlight, vk::BufferUsageFlagBits::eVertexBuffer);
+        m_PhysicsTriVB = CreateScope<UniformBuffer>(
+            *m_Device, *m_Allocator,
+            u64(Passes::PhysicsDebugPass::kMaxTriVerts) *
+                sizeof(PhysicsDebugVertex),
+            kMaxFramesInFlight, vk::BufferUsageFlagBits::eVertexBuffer);
+
         // 3.5 环境预积分生成端（compute 链）+ 中性兜底四件套。
         //     真实环境由 Application 经 AssetManager 加载后 SetEnvironment
         //     （资产路径归资产层，Renderer 不感知具体文件）
@@ -211,6 +233,41 @@ namespace Engine
         m_SceneRenderer->SetDisplayMode(mode);
     }
 
+    const FrameSceneData &Renderer::GetFrameSceneData() const
+    {
+        return m_SceneRenderer->Frame();
+    }
+
+    // ---- Editor 视口拾取（UE 式 GPU HitProxy）----
+
+    void Renderer::RequestPick(const glm::vec2& ndc)
+    {
+        m_SceneRenderer->SetPickRequest(ndc);
+    }
+
+    void Renderer::SetSelectedEntity(u32 entityBits)
+    {
+        m_SceneRenderer->SetSelectedEntity(entityBits);
+    }
+
+    std::optional<u32> Renderer::TakePickResult()
+    {
+        // 无待取结果直接返回（绝大多数帧的路径，零开销）
+        if (!m_HitProxyPass || !m_HitProxyPass->HasPendingResult()) {
+            return std::nullopt;
+        }
+
+        // 拷贝记录在上一帧的命令缓冲里：waitIdle 保证提交完成、
+        // 暂存可见（点击低频路径，单帧 hitch 不可感知）
+        m_Device->GetDevice().waitIdle();
+
+        u32 bits = 0;
+        if (!m_HitProxyPass->TakeResult(bits)) {
+            return std::nullopt;
+        }
+        return bits;
+    }
+
     void Renderer::SetEnvironment(const Cubemap* env)
     {
         if (!env) env = m_Environment.get();
@@ -305,6 +362,18 @@ namespace Engine
             "Velocity",
             RG::TextureDesc{vk::Format::eR16G16B16A16Sfloat});
 
+        // HitProxy 拾取 id 目标：R32Uint，片元写实体位模式（UE 式 GPU
+        // 拾取；请求帧才绘制，见 HitProxyPass）
+        m_HitProxyId = m_RenderGraph->CreateTexture(
+            "HitProxyId",
+            RG::TextureDesc{vk::Format::eR32Uint});
+
+        // 选中描边 mask：R8Unorm，选中实体像素 = 1（SelectionMask pass
+        // 写，Outline pass 读；UE CustomStencil 语义）
+        m_SelectionMask = m_RenderGraph->CreateTexture(
+            "SelectionMask",
+            RG::TextureDesc{vk::Format::eR8Unorm});
+
         // TAA 累积输出：既是 resolve 结果也是下一帧的历史（自引用）
         m_TAAColor = m_RenderGraph->CreateTexture(
             "TAAColor",
@@ -335,6 +404,26 @@ namespace Engine
             m_HDRColor, m_Environment.get()));
         m_Passes.push_back(CreateScope<Passes::ForwardPass>(
             *m_SceneGpu, frame, m_HDRColor, m_Velocity, m_Depth, m_ShadowMaps));
+        // 物理调试叠加：写 HDRColor（WAW 链排 Forward 之后，RAW 链在
+        // TAA 之前）——调试图元进 TAA/Bloom/Tonemap 主链路
+        m_Passes.push_back(CreateScope<Passes::PhysicsDebugPass>(
+            *m_Device, *m_Allocator, *m_ShaderManager, *m_DescriptorManager,
+            frame, m_HDRColor, m_Depth, *m_PhysicsLineVB, *m_PhysicsTriVB));
+        m_PhysicsDebugPass =
+            static_cast<Passes::PhysicsDebugPass*>(m_Passes.back().get());
+        // UE 式 GPU 拾取：请求帧把 id 画进 R32Uint + 拷贝请求像素进
+        // host 暂存（深度 WAW 链尾，排在 Forward/ForwardTrans/PhysicsDebug
+        // 之后；App 层经 RequestPick/TakePickResult 消费）
+        m_Passes.push_back(CreateScope<Passes::HitProxyPass>(
+            *m_Device, *m_Allocator, *m_ShaderManager, *m_DescriptorManager,
+            *m_SceneGpu, frame, m_HitProxyId, m_Depth));
+        m_HitProxyPass =
+            static_cast<Passes::HitProxyPass*>(m_Passes.back().get());
+        // 选中描边链：mask（只画选中实体，无深度测试=完整投影轮廓，
+        // UE 透墙可见语义）→ Outline（叠加在 Tonemap 后的 PresentTarget
+        // 上，恒定 LDR 描边色）
+        m_Passes.push_back(CreateScope<Passes::SelectionMaskPass>(
+            *m_Device, *m_ShaderManager, *m_SceneGpu, frame, m_SelectionMask));
         m_Passes.push_back(CreateScope<Passes::TAAPass>(
             *m_FullscreenGpu, frame, /*historyAlpha*/ 0.9f, m_HDRColor,
             m_Velocity, m_TAAColor));
@@ -347,6 +436,12 @@ namespace Engine
             *m_FullscreenGpu, *m_DescriptorManager, *m_PostParams, frame,
             m_TAAColor, m_BloomA, m_TemporalDiff, m_PresentTarget, m_HDRColor,
             m_Velocity, m_ShadowMaps[0], m_ShadowMaps[1], m_ShadowMaps[2]));
+        // Outline 必须在 Tonemap 之后：PresentTarget 上的 alpha 叠加若
+        // 排在 Tonemap 前，会被 Tonemap 整帧覆盖（WAW 序 = 注册序）。
+        // Blit/ImGui 之前——它们把 PresentTarget 送去 backbuffer/UI。
+        m_Passes.push_back(CreateScope<Passes::OutlinePass>(
+            *m_Device, *m_FullscreenGpu, *m_ShaderManager, frame,
+            m_SelectionMask, m_PresentTarget));
         // Direct 模式适配器：PresentTarget → backbuffer（Viewport 模式空转）。
         // 必须注册在 ImGui 之前：两者都写 backbuffer，WAW 边按声明序
         // 连接（前 writer → 后 writer），反序会让 blit 盖掉 UI
@@ -419,6 +514,9 @@ namespace Engine
         for (auto& pass : m_Passes) {
             pass->OnTargetsRebuilt(*m_RenderGraph);
         }
+        // active pass 数可能随重编译变化 → 旧写入数对不上新读取数，
+        // 每槽位重新走一次 primed 跳读
+        m_TimesPrimed[0] = m_TimesPrimed[1] = false;
         RefreshSceneTextures();
     }
 
@@ -457,18 +555,23 @@ namespace Engine
             return;
         }
 
-        const u32 passCount = m_QueriesPerFrame / 2;
-        std::vector<u64> ticks(m_QueriesPerFrame, 0);
+        // 只读上一轮该槽位实际写入的查询数：被剔除 pass 的时间戳永远
+        // 不会写入，按满额 eWait 阻塞读会等一个永不可用的查询（死锁）
+        const u32 written = m_RenderGraph->GetWrittenQueries(frameSlot);
+        if (written == 0) return;
 
-        // fence 已等待本槽位上一轮完成，结果必然可用（阻塞式 + 64bit）
+        std::vector<u64> ticks(written, 0);
+
+        // fence 已等待本槽位上一轮完成，written 范围内结果必然可用
         const vk::Result r = m_Device->GetDevice().getQueryPoolResults(
             m_QueryPool,
-            frameSlot * m_QueriesPerFrame, m_QueriesPerFrame,
-            sizeof(u64) * m_QueriesPerFrame,
+            frameSlot * m_QueriesPerFrame, written,
+            sizeof(u64) * written,
             ticks.data(), sizeof(u64),
             vk::QueryResultFlagBits::e64 | vk::QueryResultFlagBits::eWait);
         if (r != vk::Result::eSuccess) return;
 
+        const u32 passCount = written / 2;
         for (u32 i = 0; i < passCount; ++i) {
             const u64 start = ticks[i * 2];
             const u64 end = ticks[i * 2 + 1];
@@ -511,6 +614,12 @@ namespace Engine
             m_SkinOffsetBuffer->Update(frameSlot, frame.skinOffsets.data(),
                                        frame.skinOffsets.size() * sizeof(u32));
         }
+        // 实体 id 与实例矩阵同序（HitProxy id pass 按 gl_InstanceIndex 取）
+        if (!frame.instanceEntityIds.empty()) {
+            m_EntityIdBuffer->Update(frameSlot, frame.instanceEntityIds.data(),
+                                     frame.instanceEntityIds.size() *
+                                         sizeof(u32));
+        }
         if (!frame.skinPalettes.empty()) {
             m_SkinPaletteBuffer->Update(frameSlot, frame.skinPalettes.data(),
                                         frame.skinPalettes.size() *
@@ -519,6 +628,11 @@ namespace Engine
         // MDI 命令/count 同窗口落槽位 ring（fence 已等，写-读竞争关闭）
         m_SceneGpu->UploadIndirect(frameSlot, frame);
 
+        // 物理调试图元同窗口上传（fence 已等）；空帧计数归零，pass 零开销
+        if (m_PhysicsDebug && m_PhysicsDebugPass) {
+            m_PhysicsDebugPass->PrepareFrame(frameSlot, *m_PhysicsDebug);
+        }
+
         // 3. acquire swapchain image
         u32 imageIndex = 0;
         try {

Engine/src/Renderer/SceneRenderer.cpp

@@ -263,10 +263,17 @@ namespace Engine
         auto* cameraComp = scene.GetPrimaryCamera(&camTransform);
         if (!cameraComp || !camTransform) {
             // 无相机：本帧跳过（正常场景必有相机，安全网）
-            return false;
+            return false;   // 拾取请求未消费，留待下一帧重试
         }
         const Camera& camera = cameraComp->camera;
 
+        // 拾取请求落帧（一次性消费：本帧 HitProxy 渲染 + 像素拷贝）。
+        // 放在相机校验之后：跳帧时请求保留，不丢点击
+        m_Frame.pickRequest = m_PendingPick;
+        m_PendingPick.active = false;
+        // 选中实体落帧（持续状态，不做一次性清除）
+        m_Frame.selectedEntityBits = m_PendingSelected;
+
         const f32 aspect = static_cast<f32>(targetExtent.width) /
                            static_cast<f32>(targetExtent.height);
         ubo.view = camera.GetView(*camTransform);
@@ -481,6 +488,7 @@ namespace Engine
         m_Frame.instanceModels.clear();
         m_Frame.prevInstanceModels.clear();
         m_Frame.skinOffsets.clear();
+        m_Frame.instanceEntityIds.clear();
         m_MainScratch.Clear();
         for (auto& s : m_CascScratch) s.Clear();
         m_TranslucentScratch.Clear();   // 透明队列每帧重排批次，必须整帧重建
@@ -586,7 +594,8 @@ namespace Engine
                         // 实例在扁平化后连续——firstInstance 语义的前提
                         const u32 bi = batchIdx - 1;
                         s.result.batches[bi].count++;
-                        s.batchMats[bi].push_back({t.World(), prevWorld, skinBase});
+                        s.batchMats[bi].push_back(
+                            {t.World(), prevWorld, skinBase, entKey});
                         s.batchDistSum[bi] += dist;   // 透明排序用
                         s.result.instanceCount++;
                         ++totalInstances;
@@ -627,6 +636,8 @@ namespace Engine
                     m_Frame.prevInstanceModels.push_back(m.prev);
                     // 与实例序平行对齐（shader 按 gl_InstanceIndex 取）
                     m_Frame.skinOffsets.push_back(m.skinBase);
+                    // 实体位模式同序对齐（HitProxy id pass 消费）
+                    m_Frame.instanceEntityIds.push_back(m.entityBits);
                 }
             }
             dst.instanceCount = s.result.instanceCount;
@@ -680,6 +691,27 @@ namespace Engine
         }
         appendView(m_Frame.translucentView, m_TranslucentScratch);
 
+        // ---- 5.5 选中描边：从扁平实例表筛出选中实体的单实例绘制 ----
+        //（不透明 + 透明队列都查——选中玻璃也要有描边）。
+        // 无选中时保持空表，SelectionMask pass 只 clear 不绘制
+        m_Frame.selectionDraws.clear();
+        if (m_Frame.selectedEntityBits != 0) {
+            auto collect = [&](const CullResult& view) {
+                for (const auto& b : view.batches) {
+                    for (u32 i = 0; i < b.count; ++i) {
+                        const u32 idx = b.first + i;
+                        if (m_Frame.instanceEntityIds[idx] ==
+                            m_Frame.selectedEntityBits) {
+                            m_Frame.selectionDraws.push_back(
+                                SelectionDraw{b.mesh, idx, b.lod});
+                        }
+                    }
+                }
+            };
+            collect(m_Frame.mainView);
+            collect(m_Frame.translucentView);
+        }
+
         // 帧末滚动时域状态：cur → prev（每帧重建，销毁的实体自动清出）
         m_PrevWorlds.swap(m_CurWorlds);
         m_CurWorlds.clear();