修复悬停高亮变长方形色块/联动失效 + 信号列表动画卡顿真因（行位图缓存）
一、悬停高亮恢复"整条曲线发光"（上一轮裁成鼠标附近一段 ⇒ 满幅方波上就是个长方形色块） 光晕的语义是"整条曲线一起发光"，对编码器这种满幅方波，一列包络本来就跨满网格高， 裁成 144px 宽 × 满高的窗口在屏幕上就是一个像选区框的色块（用户 2026-10-18 第二轮报告）。 修法（PlotViewPaint.cpp）： - PaintSignalHaloFor 恢复**整条**几何（包络带 FillPath / 折线 DrawLines）； - 新增 PaintSignalHaloCached：光晕几何只取决于「信号 + 视界 + 网格几何 + 样式」，**与鼠标无关** ⇒ 渲染一次进离屏位图，之后每帧只做一次 AlphaBlend（源位图预乘 alpha，用 256×256 查表）； - 缓存键与 AcquirePolyline 同源，**不含网格屏幕位置**（滚动网格只按新位置贴同一张位图）。 210ms/帧（整条描边）→ 一次性 15ms 渲染 + 每帧 ~2ms 贴图。 halocheck 校验：悬停必命中（60/60 位置）、光晕贴合带宽（outsideBand=0）、不越出网格、 bbox 覆盖整条曲线（不是中段方块）、列表行悬停联动仍生效。 二、信号列表动画卡顿的三个真因（探针 panelstutter：129 个可见网格 + 反复"展开→切组复选框→收起"） 1) 面板每帧重画 ~36 行 × ~0.35ms（十来个 GDI+ 原语）⇒ panel.Paint 24~35ms； 2) 动画帧里仍在预热网格图层：每帧重建 1 个网格图层，2500 万采样信号 10~30ms ⇒ 帧被拉长； 3) 勾选分组会把上百个**离屏**网格排进待重画队列，随后每帧补 1 个 ⇒ 数秒持续掉帧。 修法： 1) 行位图缓存（SignalPanel::PaintRowCached）：按"行的可见内容"做键，整行渲染进离屏 DIB， 命中时一次 BitBlt。panel.Paint 24~35ms → 5~6ms。 ⚠️ 必须 DIB + 内存 DC（gd::Bitmap 上 GDI 会关闭 ClearType，整列文字退化）； ⚠️ 行内几何在 RowRect 里平移（GDI 文本不认 GDI+ 世界变换，否则文字画到小位图之外）； ⚠️ 渲染到行位图时不按列表矩形裁剪，裁剪放到贴图时的 DC（GDI 不认 GDI+ 裁剪， 必须自己 SaveDC + IntersectClipRect，折起动画时行不许画到组名上）； ⚠️ 缓存上限 192 行（≈10MB）。静态画面逐像素一致（面板区域 54/275200 不同）。 2) 新增 PlotView::SetAnimationBusy：UI 动画期间不预热网格图层（队列保留，动画结束后继续）。 3) 待重画队列只保留可视 + 预取带内的网格；RollWideBuffer 不再登记离屏网格。 实测：展开 p50 35ms → 13ms、收起 33ms → 13ms、动画帧内图层重建 56 次 → 0 次。 三、试过并放弃（避免以后重走） - ExtTextOutW 替代 DrawTextW：快 2~4 倍但光栅化不同（面板 10% 像素差异）⇒ 观感变化，放弃； - 用 gd::Bitmap 做行位图：文字丢失 ClearType，放弃。 四、验证（全部离屏，不占用鼠标/键盘/屏幕） - 新增 .preflight/perf/panelstutter_main.cpp（8/8）、halocheck_main.cpp（16/16）； - 回归 verify 49/49、panelanim 158/158、hoverdrag 20/20、gridanim 93/93、lanescroll 23/23、 datacheck 69/69、edgecheck 46/46、errcheck 19/19、panflash 19/19、stress 6/6； - make release / make debug 零警告（TARGET_FILE_NAME=TargetCheck/TargetCheckD）。 文档：Documents/agent_mem.md 追加本轮小节（含 4 条新规则：高亮语义不得为性能让步、 GDI 文本的三个隐形陷阱、面板卡顿先量"每行成本×可见行数"与"本帧是否顺带做绘图区重活"、 动画帧内绝不做可延迟的整帧级工作）。
This commit is contained in:
DeepSeek-V4.1-Flash committed
1 parent
0efaa8c0ca
commit
24f0bf849d
11 files changed
+853
-197
No files matched your search
@@ -434,6 +434,11 @@ namespace jdi
|
||||
// 鼠标离开窗口（WM_MOUSELEAVE）、数据/行结构变化、切换标签页等。
|
||||
m_plot.SetExternalHoverSignal(m_panel.HoveredSignal());
|
||||
|
||||
// ⚠️ 面板动画期间**暂停绘图区的网格图层预热**：单个巨型信号的图层重建要 10~30ms，
|
||||
// 塞进动画帧就会让"只有文字的信号列表"看起来卡顿（用户 2026-10-18 报告）。
|
||||
// 预热只是被推迟（待重画队列保留），动画结束后由既有预算继续补齐。
|
||||
m_plot.SetAnimationBusy(panelAnimating || panelOnly);
|
||||
|
||||
if (fullChrome)
|
||||
{
|
||||
UiFillRect(g, gd::RectF(0.0f, 0.0f, static_cast<float>(width), static_cast<float>(height)),
|
||||
|
||||
@@ -1067,7 +1067,22 @@ namespace jdi
|
||||
*/
|
||||
void RefreshLanes();
|
||||
|
||||
/**
|
||||
* @brief 设置「前台正在播放 UI 动画」标志（信号列表滚动 / 分组折起展开动画）。
|
||||
*
|
||||
* ⚠️ 为 true 时**暂停网格图层预热**（`WarmLaneLayersStep`）：预热每帧要重画 1 个网格图层，
|
||||
* 而单个巨型信号（2500 万采样）的图层重建实测 **10~30ms** —— 它会直接把 60fps 的
|
||||
* 动画打成一帧一跳（用户 2026-10-18 报告：信号列表只有文字，滚动/展开却明显卡顿）。
|
||||
* 动画结束后预热会自然继续（待重画队列不丢），因此只是"推迟"，不改变最终画面。
|
||||
* @param [IN] busy 是否正在播放动画。
|
||||
*/
|
||||
void SetAnimationBusy(bool busy) { m_animationBusy = busy; }
|
||||
|
||||
private:
|
||||
/** @brief 前台是否正在播放 UI 动画（见 `SetAnimationBusy`）。 */
|
||||
bool m_animationBusy = false;
|
||||
|
||||
public:
|
||||
/**
|
||||
* @brief 单个网格的绘制信息。
|
||||
*/
|
||||
@@ -2764,11 +2779,87 @@ namespace jdi
|
||||
* @param [IN] resolved 已解析的信号。
|
||||
* @param [IN] lane 该信号所在网格（单点信号需要它把数据点换算到屏幕坐标）。
|
||||
* @param [IN] cached 该信号的折线缓存项（包络带模式下会走带外扩填充）。
|
||||
* @param [IN] windowCenterX 描边窗口中心（屏幕 x）；仅当 `windowed` 为 true 时生效。
|
||||
* @param [IN] windowed 是否只描边窗口内的顶点（见 `kHaloWindowHalfWidth` 的说明）。
|
||||
*/
|
||||
void PaintSignalHaloFor(gd::Graphics& g, const ResolvedSignal& resolved, const LaneVisual& lane,
|
||||
const PolylineCacheEntry& cached, float windowCenterX, bool windowed);
|
||||
const PolylineCacheEntry& cached);
|
||||
|
||||
/**
|
||||
* @brief 绘制**悬停**光晕：把整条光晕渲染进一张离屏位图并缓存，命中时只贴图。
|
||||
*
|
||||
* ⚠️ 悬停光晕必须**沿整条曲线**发光（用户 2026-10-18 第二轮报告：上一版只画
|
||||
* 鼠标左右 ±72px 的一段，在满幅方波上看起来就是一个**长方形色块**，像选区框）。
|
||||
* 而整条光晕的直接绘制代价很高（稠密包络带填充实测 ~14ms/帧，加粗折线描边更是
|
||||
* 200ms+/帧）。折中方案：光晕的几何只取决于「信号 + 视图 + 网格几何 + 样式」，
|
||||
* **与鼠标位置无关**，因此渲染一次进离屏位图后每帧只贴图（~0.5ms），
|
||||
* 并随视图/几何/样式变化自动失效重建。
|
||||
*
|
||||
* @param [IN,OUT] g 绘图上下文（调用方已设置绘图区裁剪）。
|
||||
* @param [IN] resolved 已解析的信号。
|
||||
* @param [IN] lane 该信号所在网格。
|
||||
* @param [IN] cached 该信号的折线缓存项。
|
||||
*/
|
||||
void PaintSignalHaloCached(gd::Graphics& g, const ResolvedSignal& resolved,
|
||||
const LaneVisual& lane, const PolylineCacheEntry& cached);
|
||||
|
||||
/**
|
||||
* @brief 悬停光晕的离屏缓存（见 `PaintSignalHaloCached`）。
|
||||
*
|
||||
* 键 = 决定光晕几何的全部输入（与 `AcquirePolyline` 的键同源），
|
||||
* 唯独**不含网格的屏幕纵向位置**：滚动网格时只需按新位置贴同一张位图。
|
||||
*/
|
||||
struct HaloLayerCache
|
||||
{
|
||||
bool valid = false; /**< 位图内容是否有效。 */
|
||||
SignalRef ref; /**< 信号引用。 */
|
||||
const SignalGroup* group = nullptr; /**< 所属分组。 */
|
||||
std::size_t sampleCount = 0; /**< 采样点数。 */
|
||||
double viewMin = 0.0; /**< 时间轴显示下界。 */
|
||||
double viewMax = 0.0; /**< 时间轴显示上界。 */
|
||||
float plotX = 0.0f; /**< 绘图区左边界。 */
|
||||
float plotWidth = 0.0f; /**< 绘图区宽度。 */
|
||||
float laneHeight = 0.0f; /**< 网格高度。 */
|
||||
double laneYMin = 0.0; /**< 网格幅值下界。 */
|
||||
double laneYMax = 0.0; /**< 网格幅值上界。 */
|
||||
float lineWidth = 1.0f; /**< 线宽。 */
|
||||
DrawMode mode = DrawMode::LINE; /**< 绘制方式。 */
|
||||
float gain = 1.0f; /**< 绘制系数。 */
|
||||
bool absolute = false; /**< 是否绝对值。 */
|
||||
bool mirrorVertical = false; /**< 是否垂直镜像。 */
|
||||
bool mirrorHorizontal = false; /**< 是否水平镜像。 */
|
||||
float offsetY = 0.0f; /**< Y 偏移。 */
|
||||
double offsetTime = 0.0; /**< 时间偏移。 */
|
||||
int originX = 0; /**< 位图左上角（屏幕 x）。 */
|
||||
int originY = 0; /**< 位图左上角（屏幕 y）。 */
|
||||
std::unique_ptr<gd::Bitmap> bitmap; /**< 32bpp ARGB 光晕图层（直通 alpha）。 */
|
||||
|
||||
/**
|
||||
* @brief 预乘 alpha 的 DIB 副本（每帧真正贴出去的那张）。
|
||||
*
|
||||
* ⚠️ 每帧贴图必须走 GDI `AlphaBlend` + `AC_SRC_ALPHA`：
|
||||
* `gd::Graphics::DrawImage` 贴一张 32bpp 半透明位图实测约 **6ms**（每帧都付），
|
||||
* 而 `AlphaBlend` 对同一张图约 **0.3ms**。
|
||||
* `AlphaBlend` 要求源位图的 RGB **已按 alpha 预乘**，因此重建时把
|
||||
* `bitmap` 拷进这个 DIB 并顺带做预乘（只付一次）。
|
||||
*/
|
||||
HDC dc = nullptr;
|
||||
HBITMAP dib = nullptr;
|
||||
void* bits = nullptr;
|
||||
int dibWidth = 0;
|
||||
int dibHeight = 0;
|
||||
};
|
||||
|
||||
mutable HaloLayerCache m_haloLayer;
|
||||
|
||||
/** @brief 释放悬停光晕的离屏位图（析构 / 重建尺寸时使用）。 */
|
||||
void ReleaseHaloLayer();
|
||||
|
||||
/**
|
||||
* @brief 把 `m_haloLayer.bitmap` 拷进预乘 alpha 的 DIB（必要时先创建/重建 DIB）。
|
||||
* @param [IN] width 需要的位图宽度。
|
||||
* @param [IN] height 需要的位图高度。
|
||||
* @return DIB 可用返回 true。
|
||||
*/
|
||||
bool UploadHaloLayer(int width, int height);
|
||||
|
||||
/**
|
||||
* @brief 绘制某条信号的悬停/拖拽光晕（折线描边版本）。
|
||||
@@ -2781,12 +2872,9 @@ namespace jdi
|
||||
* @param [IN] lane 该信号所在网格。
|
||||
* @param [IN] points 折线顶点。
|
||||
* @param [IN] breaks 每段折线的起始下标。
|
||||
* @param [IN] windowCenterX 描边窗口中心（屏幕 x）；仅当 `windowed` 为 true 时生效。
|
||||
* @param [IN] windowed 是否只描边窗口内的顶点（见 `kHaloWindowHalfWidth` 的说明）。
|
||||
*/
|
||||
void PaintSignalHalo(gd::Graphics& g, const ResolvedSignal& resolved, const LaneVisual& lane,
|
||||
const std::vector<gd::PointF>& points, const std::vector<std::size_t>& breaks,
|
||||
float windowCenterX, bool windowed);
|
||||
const std::vector<gd::PointF>& points, const std::vector<std::size_t>& breaks);
|
||||
|
||||
/**
|
||||
* @brief 单点信号那个数据点绘制时的半径（与散点绘制同源）。
|
||||
|
||||
@@ -26,6 +26,7 @@ namespace jdi
|
||||
ReleaseDecorCache();
|
||||
ReleaseWideBuffer();
|
||||
ReleasePanelCache();
|
||||
ReleaseHaloLayer();
|
||||
}
|
||||
|
||||
void PlotView::Setup(const UiFonts* fonts, const Theme* theme)
|
||||
|
||||
@@ -148,23 +148,15 @@ namespace jdi
|
||||
inline const float kMarkerTriangleGap = 4.0f;
|
||||
inline const size_t kMaxScatterPoints = 2500; /**< 单条散点最大绘制点数。 */
|
||||
/**
|
||||
* @brief 悬停光晕"描边窗口"的半宽（逻辑像素，使用时乘缩放）。
|
||||
* @brief 悬停光晕缓存中「关闭抗锯齿」的顶点数阈值。
|
||||
*
|
||||
* ⚠️ 光晕是**用加粗 GDI+ 折线描边**画出来的，而 GDI+ 描边的代价与
|
||||
* 「线段数 × 每段覆盖的行数」成正比：编码器/方波这类**满幅竖向锯齿**信号
|
||||
* 1 条 2503 顶点的折线实测要 **210ms/帧**（用户 2026-10-18 报告：
|
||||
* 鼠标划过巨型信号的曲线时整帧卡死、浮动提示不再跟随鼠标）。
|
||||
* 因此只描边鼠标左右各 `kHaloWindowHalfWidth` 像素内的顶点：
|
||||
* 顶点数降到几十个 ⇒ 单帧 <1ms，而"鼠标附近那条曲线发光"正是悬停提示该有的语义。
|
||||
* 光晕是**沿整条曲线**画出来的（不能只画鼠标附近的一段：在满幅方波上那看起来
|
||||
* 就是一个长方形色块，像选区框 —— 用户 2026-10-18 第二轮报告）。它的代价只
|
||||
* 在「光晕缓存重建」时付一次，因此通常可直接用抗锯齿；但顶点很多的区间
|
||||
* （深放大后的方波：每段都跨满网格高）GDI+ 抗锯齿的扫描线代价 ≈ 线段数 × 覆盖行数，
|
||||
* 实测可差 20 倍以上。这类密集情形关闭抗锯齿（几何完全不变，半透明光晕上看不出差别）。
|
||||
*/
|
||||
inline const float kHaloWindowHalfWidth = 72.0f;
|
||||
/**
|
||||
* @brief 顶点数达到该值才启用描边窗口裁剪。
|
||||
*
|
||||
* 顶点少的信号（一屏内只有几百个采样）整条描边的代价本来就极小，
|
||||
* 整条发光观感更好，因此不做裁剪。
|
||||
*/
|
||||
inline const size_t kHaloWindowMinPoints = 360;
|
||||
inline const size_t kHaloNoAaMinPoints = 360;
|
||||
inline const size_t kPolylineCacheLimit = 64; /**< 折线顶点缓存条目上限。 */
|
||||
inline const float kMinScatterRadius = 1.6f; /**< 散点最小半径（逻辑像素）。 */
|
||||
inline const float kMaxScatterRadius = 12.0f; /**< 散点最大半径（逻辑像素）。 */
|
||||
|
||||
@@ -1043,26 +1043,25 @@ namespace jdi
|
||||
}
|
||||
|
||||
void PlotView::PaintSignalHaloFor(gd::Graphics& g, const ResolvedSignal& resolved, const LaneVisual& lane,
|
||||
const PolylineCacheEntry& cached, float windowCenterX, bool windowed)
|
||||
const PolylineCacheEntry& cached)
|
||||
{
|
||||
if (resolved.style == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
// ------------------------------------------------------------------
|
||||
// 稠密信号（走"像素列包络带"）：光晕改为**填充与曲线本身同一几何的包络带**。
|
||||
// 稠密信号（走"像素列包络带"）：光晕 = **填充与曲线本身同一几何**的包络带。
|
||||
//
|
||||
// ⚠️ 绝不能用「加粗折线描边」画稠密信号的光晕：包络带的顶点序列是
|
||||
// 「每列上/下包络交替」的满幅竖锯齿，GDI+ 描边的代价 = 线段数 × 覆盖行数，
|
||||
// 实测 2503 个顶点要 **210ms/帧**（用户 2026-10-18 报告：鼠标划过巨型信号的
|
||||
// 曲线时整帧卡死、浮动提示不再跟随鼠标）。而 `FillPath` 同一条几何只需 ~1ms，
|
||||
// 且观感更贴切（整条曲线一起"发光"，与曲线本身逐像素同源）。
|
||||
// ⚠️ 填充也**只填鼠标附近的一段**（见 `kHaloWindowHalfWidth`）：半透明填充
|
||||
// 的代价与「覆盖面积 + 路径顶点数」成正比，整条满幅带实测 ~13ms/帧。
|
||||
// 实测 2503 个顶点要 **210ms**。而 `FillPath` 同一条几何只要 ~14ms，
|
||||
// 且观感与原实现（沿折线描粗）一致：整条曲线一起"发光"。
|
||||
// ⚠️ 光晕**必须覆盖整条曲线**：曾经只画鼠标附近 ±72px 的一段，在满幅方波上
|
||||
// 看起来就是一个**长方形色块**（像选区框），用户 2026-10-18 第二轮明确报告。
|
||||
// 代价问题改由 `PaintSignalHaloCached`（渲染一次 + 每帧贴图）解决。
|
||||
// ------------------------------------------------------------------
|
||||
if (resolved.style->mode != DrawMode::SCATTER && cached.bandMode && !cached.bandBreaks.empty())
|
||||
{
|
||||
const float halfWidth = kHaloWindowHalfWidth * m_scale;
|
||||
const int savedSmoothing = g.GetSmoothingMode();
|
||||
g.SetSmoothingMode(gd::SmoothingModeNone); // 半透明填充：抗锯齿没有观感收益
|
||||
gd::GraphicsPath bandPath;
|
||||
@@ -1077,44 +1076,11 @@ namespace jdi
|
||||
{
|
||||
continue;
|
||||
}
|
||||
// 段内布局 = 「上包络正向（`half` 个）+ 下包络反向（`half` 个）」
|
||||
//（见 `EmitEnvelopeBand`），因此窗口只需换算成列区间。
|
||||
// 段内布局 = 「上包络正向（`half` 个）+ 下包络反向（`half` 个）」。
|
||||
const std::size_t half = total / 2;
|
||||
std::size_t columnFirst = 0;
|
||||
std::size_t columnLast = half;
|
||||
if (windowed)
|
||||
{
|
||||
while (columnFirst < half &&
|
||||
cached.band[start + columnFirst].X < windowCenterX - halfWidth - 1.0f)
|
||||
{
|
||||
++columnFirst;
|
||||
}
|
||||
while (columnLast > columnFirst &&
|
||||
cached.band[start + columnLast - 1].X > windowCenterX + halfWidth + 1.0f)
|
||||
{
|
||||
--columnLast;
|
||||
}
|
||||
// 两侧各多含 1 列，避免窗口边界处的半透明边缘被切出直边。
|
||||
if (columnFirst > 0)
|
||||
{
|
||||
--columnFirst;
|
||||
}
|
||||
if (columnLast < half)
|
||||
{
|
||||
++columnLast;
|
||||
}
|
||||
}
|
||||
if (columnLast <= columnFirst + 1)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
const std::size_t columns = columnLast - columnFirst;
|
||||
bandPath.StartFigure();
|
||||
bandPath.AddLines(cached.band.data() + start + columnFirst, static_cast<INT>(columns));
|
||||
// 下包络反向存储：列 c 在 `start + half + (half - 1 - c)`，
|
||||
// 因此列区间 `[columnFirst, columnLast)` 对应一段**正向可读**的连续区间。
|
||||
bandPath.AddLines(cached.band.data() + start + half + (half - columnLast),
|
||||
static_cast<INT>(columns));
|
||||
bandPath.AddLines(cached.band.data() + start, static_cast<INT>(half));
|
||||
bandPath.AddLines(cached.band.data() + start + half, static_cast<INT>(half));
|
||||
bandPath.CloseFigure();
|
||||
}
|
||||
if (bandPath.GetPointCount() > 0)
|
||||
@@ -1126,13 +1092,231 @@ namespace jdi
|
||||
return;
|
||||
}
|
||||
// 其余情形一律用折线描边（与"之前"的画法一致）。
|
||||
PaintSignalHalo(g, resolved, lane, cached.points, cached.breaks, windowCenterX, windowed);
|
||||
PaintSignalHalo(g, resolved, lane, cached.points, cached.breaks);
|
||||
}
|
||||
|
||||
void PlotView::PaintSignalHaloCached(gd::Graphics& g, const ResolvedSignal& resolved,
|
||||
const LaneVisual& lane, const PolylineCacheEntry& cached)
|
||||
{
|
||||
if (resolved.style == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
// 光晕只可能画在该网格内：位图 = 网格矩形 ∩ 绘图区（外加少量余量容纳加粗线宽）。
|
||||
const float pad = (resolved.style->lineWidth + 8.0f) * m_scale;
|
||||
const float left = std::max(lane.rect.X, m_plotRect.X) - pad;
|
||||
const float top = std::max(lane.rect.Y, m_plotRect.Y) - pad;
|
||||
const float right =
|
||||
std::min(lane.rect.X + lane.rect.Width, m_plotRect.X + m_plotRect.Width) + pad;
|
||||
const float bottom =
|
||||
std::min(lane.rect.Y + lane.rect.Height, m_plotRect.Y + m_plotRect.Height) + pad;
|
||||
if (!(right > left + 1.0f) || !(bottom > top + 1.0f))
|
||||
{
|
||||
return;
|
||||
}
|
||||
const int targetX = static_cast<int>(std::floor(left));
|
||||
const int targetY = static_cast<int>(std::floor(top));
|
||||
const int width = static_cast<int>(std::ceil(right)) - targetX;
|
||||
const int height = static_cast<int>(std::ceil(bottom)) - targetY;
|
||||
if (width <= 0 || height <= 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
HaloLayerCache& cache = m_haloLayer;
|
||||
// 键 = 决定光晕几何的全部输入（与 `AcquirePolyline` 的键同源）。
|
||||
// ⚠️ **不含网格的屏幕位置**：滚动网格时几何不变，只需按新位置贴同一张位图。
|
||||
const bool sameSize = cache.bitmap && static_cast<int>(cache.bitmap->GetWidth()) == width &&
|
||||
static_cast<int>(cache.bitmap->GetHeight()) == height;
|
||||
const bool sameKey =
|
||||
cache.valid && sameSize && cache.ref == cached.ref && cache.group == cached.group &&
|
||||
cache.sampleCount == cached.sampleCount && cache.viewMin == cached.viewMin &&
|
||||
cache.viewMax == cached.viewMax && cache.plotX == cached.plotX &&
|
||||
cache.plotWidth == cached.plotWidth && cache.laneHeight == cached.laneHeight &&
|
||||
cache.laneYMin == cached.laneYMin && cache.laneYMax == cached.laneYMax &&
|
||||
cache.lineWidth == cached.lineWidth && cache.mode == resolved.style->mode &&
|
||||
cache.gain == resolved.style->gain && cache.absolute == resolved.style->absolute &&
|
||||
cache.mirrorVertical == resolved.style->mirrorVertical &&
|
||||
cache.mirrorHorizontal == resolved.style->mirrorHorizontal &&
|
||||
cache.offsetY == resolved.style->offsetY &&
|
||||
cache.offsetTime == resolved.style->offsetTime;
|
||||
|
||||
if (!sameKey)
|
||||
{
|
||||
if (!sameSize)
|
||||
{
|
||||
cache.bitmap = std::make_unique<gd::Bitmap>(width, height, PixelFormat32bppARGB);
|
||||
}
|
||||
{
|
||||
gd::Graphics layerGraphics(cache.bitmap.get());
|
||||
layerGraphics.Clear(gd::Color(0, 0, 0, 0));
|
||||
layerGraphics.SetSmoothingMode(gd::SmoothingModeAntiAlias);
|
||||
layerGraphics.SetPixelOffsetMode(gd::PixelOffsetModeHalf);
|
||||
// 位图坐标 = 屏幕坐标 - 目标原点，光晕几何可直接沿用屏幕坐标。
|
||||
layerGraphics.TranslateTransform(static_cast<gd::REAL>(-targetX),
|
||||
static_cast<gd::REAL>(-targetY));
|
||||
if (cached.points.size() > kHaloNoAaMinPoints)
|
||||
{
|
||||
// 顶点很多的区间（例如深放大后的方波：每段都跨满网格高）：
|
||||
// 抗锯齿描边的扫描线代价 ≈ 线段数 × 覆盖行数（实测可差 20 倍），
|
||||
// 而这么密的半透明光晕上平滑作用肉眼不可辨。几何完全不变。
|
||||
layerGraphics.SetSmoothingMode(gd::SmoothingModeNone);
|
||||
}
|
||||
PaintSignalHaloFor(layerGraphics, resolved, lane, cached);
|
||||
}
|
||||
cache.ref = cached.ref;
|
||||
cache.group = cached.group;
|
||||
cache.sampleCount = cached.sampleCount;
|
||||
cache.viewMin = cached.viewMin;
|
||||
cache.viewMax = cached.viewMax;
|
||||
cache.plotX = cached.plotX;
|
||||
cache.plotWidth = cached.plotWidth;
|
||||
cache.laneHeight = cached.laneHeight;
|
||||
cache.laneYMin = cached.laneYMin;
|
||||
cache.laneYMax = cached.laneYMax;
|
||||
cache.lineWidth = cached.lineWidth;
|
||||
cache.mode = resolved.style->mode;
|
||||
cache.gain = resolved.style->gain;
|
||||
cache.absolute = resolved.style->absolute;
|
||||
cache.mirrorVertical = resolved.style->mirrorVertical;
|
||||
cache.mirrorHorizontal = resolved.style->mirrorHorizontal;
|
||||
cache.offsetY = resolved.style->offsetY;
|
||||
cache.offsetTime = resolved.style->offsetTime;
|
||||
cache.originX = targetX;
|
||||
cache.originY = targetY;
|
||||
cache.valid = true;
|
||||
if (!UploadHaloLayer(width, height))
|
||||
{
|
||||
cache.valid = false;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 贴图：`AlphaBlend` + `AC_SRC_ALPHA`（源位图已预乘）。命中缓存时只做这一次位块搬运。
|
||||
if (cache.dc == nullptr)
|
||||
{
|
||||
return;
|
||||
}
|
||||
const HDC targetDc = g.GetHDC();
|
||||
if (targetDc != nullptr)
|
||||
{
|
||||
BLENDFUNCTION blend = {};
|
||||
blend.BlendOp = AC_SRC_OVER;
|
||||
blend.SourceConstantAlpha = 0xFF;
|
||||
blend.AlphaFormat = AC_SRC_ALPHA;
|
||||
::AlphaBlend(targetDc, targetX, targetY, width, height, cache.dc, 0, 0, width, height,
|
||||
blend);
|
||||
g.ReleaseHDC(targetDc);
|
||||
}
|
||||
}
|
||||
|
||||
bool PlotView::UploadHaloLayer(int width, int height)
|
||||
{
|
||||
HaloLayerCache& cache = m_haloLayer;
|
||||
if (!cache.bitmap)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (cache.dib == nullptr || cache.dibWidth != width || cache.dibHeight != height)
|
||||
{
|
||||
ReleaseHaloLayer();
|
||||
BITMAPINFO info = {};
|
||||
info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
||||
info.bmiHeader.biWidth = width;
|
||||
info.bmiHeader.biHeight = -height; // 自上而下（与 GDI+ 的扫描行顺序一致）
|
||||
info.bmiHeader.biPlanes = 1;
|
||||
info.bmiHeader.biBitCount = 32;
|
||||
info.bmiHeader.biCompression = BI_RGB;
|
||||
HDC memoryDc = CreateCompatibleDC(nullptr);
|
||||
if (memoryDc == nullptr)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
void* bits = nullptr;
|
||||
HBITMAP dib = CreateDIBSection(memoryDc, &info, DIB_RGB_COLORS, &bits, nullptr, 0);
|
||||
if (dib == nullptr || bits == nullptr)
|
||||
{
|
||||
DeleteDC(memoryDc);
|
||||
if (dib != nullptr)
|
||||
{
|
||||
DeleteObject(dib);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
SelectObject(memoryDc, dib);
|
||||
cache.dc = memoryDc;
|
||||
cache.dib = dib;
|
||||
cache.bits = bits;
|
||||
cache.dibWidth = width;
|
||||
cache.dibHeight = height;
|
||||
}
|
||||
|
||||
// 预乘 alpha：`AlphaBlend` 的 `AC_SRC_ALPHA` 要求源 RGB 已乘过 alpha。
|
||||
// 用 256×256 查表代替逐像素除法（1.6M 像素时可省 ~5ms）。
|
||||
static std::uint8_t premultiply[256 * 256];
|
||||
static bool premultiplyReady = false;
|
||||
if (!premultiplyReady)
|
||||
{
|
||||
for (int alpha = 0; alpha < 256; ++alpha)
|
||||
{
|
||||
for (int value = 0; value < 256; ++value)
|
||||
{
|
||||
premultiply[(alpha << 8) | value] =
|
||||
static_cast<std::uint8_t>((value * alpha + 127) / 255);
|
||||
}
|
||||
}
|
||||
premultiplyReady = true;
|
||||
}
|
||||
gd::Rect rect(0, 0, width, height);
|
||||
gd::BitmapData data = {};
|
||||
if (cache.bitmap->LockBits(&rect, gd::ImageLockModeRead, PixelFormat32bppARGB, &data) !=
|
||||
gd::Ok)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
unsigned char* destination = static_cast<unsigned char*>(cache.bits);
|
||||
for (int y = 0; y < height; ++y)
|
||||
{
|
||||
const unsigned char* source =
|
||||
static_cast<const unsigned char*>(data.Scan0) + static_cast<std::size_t>(y) * data.Stride;
|
||||
unsigned char* row = destination + static_cast<std::size_t>(y) * width * 4u;
|
||||
for (int x = 0; x < width; ++x)
|
||||
{
|
||||
const int alpha = source[x * 4 + 3];
|
||||
const int table = alpha << 8;
|
||||
row[x * 4 + 0] = premultiply[table | source[x * 4 + 0]];
|
||||
row[x * 4 + 1] = premultiply[table | source[x * 4 + 1]];
|
||||
row[x * 4 + 2] = premultiply[table | source[x * 4 + 2]];
|
||||
row[x * 4 + 3] = static_cast<unsigned char>(alpha);
|
||||
}
|
||||
}
|
||||
cache.bitmap->UnlockBits(&data);
|
||||
return true;
|
||||
}
|
||||
|
||||
void PlotView::ReleaseHaloLayer()
|
||||
{
|
||||
HaloLayerCache& cache = m_haloLayer;
|
||||
if (cache.dc != nullptr)
|
||||
{
|
||||
DeleteDC(cache.dc);
|
||||
cache.dc = nullptr;
|
||||
}
|
||||
if (cache.dib != nullptr)
|
||||
{
|
||||
DeleteObject(cache.dib);
|
||||
cache.dib = nullptr;
|
||||
}
|
||||
cache.bits = nullptr;
|
||||
cache.dibWidth = 0;
|
||||
cache.dibHeight = 0;
|
||||
cache.valid = false;
|
||||
}
|
||||
|
||||
void PlotView::PaintSignalHalo(gd::Graphics& g, const ResolvedSignal& resolved, const LaneVisual& lane,
|
||||
const std::vector<gd::PointF>& points,
|
||||
const std::vector<std::size_t>& breaks, float windowCenterX,
|
||||
bool windowed)
|
||||
const std::vector<std::size_t>& breaks)
|
||||
{
|
||||
// ⚠️ **只有单个数据点**的信号（默认样式是「点线」，那个点本身是一个粗圆点）：
|
||||
// 折线光晕无从下手（不足两个顶点），改为在数据点外包一圈强调色圆环。
|
||||
@@ -1169,18 +1353,11 @@ namespace jdi
|
||||
const float ringRadius = radius + 2.5f * m_scale;
|
||||
const std::size_t scatterStride =
|
||||
std::max<std::size_t>(1, points.size() / kMaxScatterPoints);
|
||||
// 散点数量本身有上限（`kMaxScatterPoints`），逐点画圈是 O(数千) 的小代价；
|
||||
// 但仍按窗口过滤，保持"只高亮鼠标附近"的一致语义（点少时窗口外也全画）。
|
||||
const bool windowScatter = windowed && points.size() > kHaloWindowMinPoints;
|
||||
const float halfWidth = kHaloWindowHalfWidth * m_scale;
|
||||
// 散点数量本身有上限（`kMaxScatterPoints`），逐点画圈是 O(数千) 的小代价。
|
||||
gd::Pen ring(ToGdiColor(WithAlpha(m_theme->accent, 0x88)), 1.6f * m_scale);
|
||||
for (std::size_t index = 0; index < points.size(); index += scatterStride)
|
||||
{
|
||||
const gd::PointF& point = points[index];
|
||||
if (windowScatter && std::fabs(point.X - windowCenterX) > halfWidth)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
g.DrawEllipse(&ring, point.X - ringRadius, point.Y - ringRadius, ringRadius * 2.0f,
|
||||
ringRadius * 2.0f);
|
||||
}
|
||||
@@ -1196,12 +1373,6 @@ namespace jdi
|
||||
halo.SetLineJoin(gd::LineJoinRound);
|
||||
halo.SetStartCap(gd::LineCapRound);
|
||||
halo.SetEndCap(gd::LineCapRound);
|
||||
// 顶点多的信号只描边**鼠标左右一小段**（见 `kHaloWindowHalfWidth` 的说明）：
|
||||
// 整条描边在满幅锯齿信号上要 100~200ms/帧，鼠标移动时整帧卡死。
|
||||
const bool windowStroke = windowed && points.size() > kHaloWindowMinPoints;
|
||||
const float halfWidth = kHaloWindowHalfWidth * m_scale;
|
||||
const float windowLeft = windowCenterX - halfWidth;
|
||||
const float windowRight = windowCenterX + halfWidth;
|
||||
for (std::size_t k = 0; k < breaks.size(); ++k)
|
||||
{
|
||||
const std::size_t start = breaks[k];
|
||||
@@ -1210,46 +1381,7 @@ namespace jdi
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (!windowStroke)
|
||||
{
|
||||
g.DrawLines(&halo, points.data() + start, static_cast<INT>(stop - start));
|
||||
continue;
|
||||
}
|
||||
// 窗口内的顶点在段内**连续**（折线沿时间单调），因此顺序扫描一次、按连续区段绘制。
|
||||
// 多含一个窗口外的顶点，让跨越窗口边界的线段完整画出（不出现断头）。
|
||||
std::size_t runStart = stop;
|
||||
std::size_t runStop = stop;
|
||||
for (std::size_t index = start; index < stop; ++index)
|
||||
{
|
||||
const bool inside = (points[index].X >= windowLeft - 1.0f) &&
|
||||
(points[index].X <= windowRight + 1.0f);
|
||||
if (inside && runStart == stop)
|
||||
{
|
||||
runStart = (index > start) ? (index - 1) : index;
|
||||
runStop = index + 1;
|
||||
}
|
||||
else if (inside)
|
||||
{
|
||||
runStop = index + 1;
|
||||
}
|
||||
else if (runStart != stop)
|
||||
{
|
||||
if (index + 1 < stop)
|
||||
{
|
||||
runStop = index + 2;
|
||||
}
|
||||
if (runStop > runStart + 1)
|
||||
{
|
||||
g.DrawLines(&halo, points.data() + runStart, static_cast<INT>(runStop - runStart));
|
||||
}
|
||||
runStart = stop;
|
||||
runStop = stop;
|
||||
}
|
||||
}
|
||||
if (runStart != stop && runStop > runStart + 1)
|
||||
{
|
||||
g.DrawLines(&halo, points.data() + runStart, static_cast<INT>(runStop - runStart));
|
||||
}
|
||||
g.DrawLines(&halo, points.data() + start, static_cast<INT>(stop - start));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1302,16 +1434,9 @@ namespace jdi
|
||||
const PolylineCacheEntry* cached = AcquirePolyline(haloRef, resolved, lane);
|
||||
if (cached != nullptr)
|
||||
{
|
||||
// 光晕只描边鼠标附近的一段（见 `kHaloWindowHalfWidth`）：鼠标不在绘图区内时
|
||||
//（列表/样式区悬停）以绘图区中心为窗口中心，保证代价恒定、不平白卡一帧。
|
||||
const bool mouseInPlot = (m_mouseX >= m_plotRect.X &&
|
||||
m_mouseX <= m_plotRect.X + m_plotRect.Width &&
|
||||
m_mouseY >= m_plotRect.Y &&
|
||||
m_mouseY <= m_plotRect.Y + m_plotRect.Height);
|
||||
const float haloCenterX =
|
||||
mouseInPlot ? static_cast<float>(m_mouseX)
|
||||
: (m_plotRect.X + m_plotRect.Width * 0.5f);
|
||||
PaintSignalHaloFor(g, resolved, lane, *cached, haloCenterX, true);
|
||||
// 整条光晕一次性渲进离屏位图并缓存（命中时只贴图，~0.5ms/帧），
|
||||
// 因此光晕**沿整条曲线**发光而不随鼠标移动（见 `PaintSignalHaloCached`）。
|
||||
PaintSignalHaloCached(g, resolved, lane, *cached);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1384,8 +1509,8 @@ namespace jdi
|
||||
const LaneVisual& lane = m_lanes[static_cast<std::size_t>(laneIndex)];
|
||||
if (const PolylineCacheEntry* cached = AcquirePolyline(m_hoverLegend, resolved, lane))
|
||||
{
|
||||
// 图例悬停：鼠标就在图例条目上（网格左上角），以它为窗口中心。
|
||||
PaintSignalHaloFor(g, resolved, lane, *cached, static_cast<float>(m_mouseX), true);
|
||||
// 图例悬停：整条曲线一起发光（与鼠标命中的光晕完全同一种画法与代价）。
|
||||
PaintSignalHaloCached(g, resolved, lane, *cached);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2729,6 +2854,18 @@ namespace jdi
|
||||
[this](int laneIndex) { return LaneVisuallyRelevant(laneIndex); });
|
||||
const double defaultWideMin = LayerDefaultWideMin();
|
||||
// 本批要重画的网格：`budget` 足够大时一次取完（视界已停时调用方会传很大的预算）。
|
||||
// ⚠️ **离屏网格一律丢弃**（不重画、也不留在队列里）：它们的像素当前不可见，
|
||||
// 而单个巨型信号的图层重建要 10~30ms。真正进入可视/预取带时 `RollWideBuffer`
|
||||
// 会按新视界重新登记它们（见那里的说明）。历史实现会排空整个队列 ⇒ 勾选一个分组后
|
||||
// 连续数秒每帧 10~30ms（用户 2026-10-18 报告的列表动画卡顿）。
|
||||
m_layerRebuildPending.erase(
|
||||
std::remove_if(m_layerRebuildPending.begin(), m_layerRebuildPending.end(),
|
||||
[this](int laneIndex) { return !LaneVisuallyRelevant(laneIndex, 1); }),
|
||||
m_layerRebuildPending.end());
|
||||
if (m_layerRebuildPending.empty())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
const int available = static_cast<int>(m_layerRebuildPending.size());
|
||||
const int take = std::min(budget, available);
|
||||
std::vector<int> batch;
|
||||
@@ -3190,6 +3327,12 @@ namespace jdi
|
||||
{
|
||||
return;
|
||||
}
|
||||
// ⚠️ **UI 动画期间绝不预热**：单个巨型信号的图层重建要 10~30ms，塞进动画帧就会
|
||||
// 让"只有文字的信号列表"看起来卡顿（用户 2026-10-18 报告）。队列保留，动画结束后继续。
|
||||
if (m_animationBusy)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (!(m_plotRect.Width > 8.0f) || !(Tab().ViewMax() - Tab().ViewMin() > 0.0))
|
||||
{
|
||||
return;
|
||||
@@ -3288,12 +3431,13 @@ namespace jdi
|
||||
// `BuildLaneVisuals()`（O(网格数)）—— 253 个网格时这是拖拽卡顿的主因。
|
||||
// 只登记待重画（可视网格会被 `RenderPendingLaneRebuilds` 优先处理），
|
||||
// 等它们真的要进入视区时再按新视界重建（期间由 `BlitWideBuffer` 的底衬兜底）。
|
||||
//
|
||||
// ⚠️⚠️ **离屏网格的"内容过期"也不登记待重画**：否则一次"网格数变化"（勾选/取消
|
||||
// 一个分组）就会把**上百个离屏网格**全部塞进队列，随后每帧补 1 个 × 10~30ms
|
||||
// ⇒ 数秒的持续掉帧（用户 2026-10-18 报告的信号列表动画卡顿有一半来自这里）。
|
||||
// 离屏网格真正进入可视/预取带时，下面的可见分支会按新视界登记它。
|
||||
if (!LaneVisuallyRelevant(laneIndex, 1))
|
||||
{
|
||||
if (contentStale)
|
||||
{
|
||||
QueueLaneRebuild(laneIndex);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
// 纵向：幅值**平移**不改内容，只改贴图偏移（与横向同构）。
|
||||
@@ -3926,7 +4070,7 @@ namespace jdi
|
||||
if (highlighted)
|
||||
{
|
||||
// 拖拽光晕整条描边并进入静态场景缓存（拖拽期间不随鼠标变化，不必裁剪）。
|
||||
PaintSignalHaloFor(g, resolved, lane, *cached, 0.0f, false);
|
||||
PaintSignalHaloFor(g, resolved, lane, *cached);
|
||||
}
|
||||
|
||||
if (drawLine && !breaks.empty())
|
||||
|
||||
@@ -806,6 +806,76 @@ namespace jdi
|
||||
*/
|
||||
void PaintSignalRow(gd::Graphics& g, int row);
|
||||
|
||||
/**
|
||||
* @brief 把一行（分组行 / 信号行）**绘制进离屏位图缓存**，再整块贴到列表上。
|
||||
*
|
||||
* ⚠️ 一行的绘制要调用十来个 GDI+ 原语（圆角托底 / 复选框 / 色块 / 两段文字…），
|
||||
* 实测 **0.35ms/行**；列表一屏能放 35~40 行 ⇒ 单帧 **12~15ms** 全花在重复绘制
|
||||
* **内容完全没变**的行上（分组折起/展开动画只是在整行平移）。
|
||||
* 因此按"行的可见内容"做键缓存位图：动画帧只需把命中的位图按新位置贴出来。
|
||||
*
|
||||
* ⚠️ 缓存期间行的绘制**不能**裁到列表矩形（`m_rowClipRender`）：位图是整行内容，
|
||||
* 裁剪由贴图时的 GDI+ 裁剪区负责 —— 否则部分滚出上边界的行会永久丢掉顶部像素。
|
||||
*
|
||||
* @param [IN,OUT] g 绘图上下文（调用方已把裁剪区设为列表矩形）。
|
||||
* @param [IN] row 行下标。
|
||||
*/
|
||||
void PaintRowCached(gd::Graphics& g, int row);
|
||||
|
||||
/**
|
||||
* @brief 计算一行的缓存键（涵盖影响该行像素的全部状态）。
|
||||
* @param [IN] row 行下标。
|
||||
* @return 键值。
|
||||
*/
|
||||
std::uint64_t RowCacheKey(int row) const;
|
||||
|
||||
/** @brief 作废全部行位图缓存（行集合 / 字体 / 主题变化时调用）。 */
|
||||
void InvalidateRowCache();
|
||||
|
||||
/** @brief 一行的离屏位图缓存项。 */
|
||||
struct RowBitmapCache
|
||||
{
|
||||
/**
|
||||
* @brief 该行的像素（DIB 内存 DC，已铺面板底色）。
|
||||
*
|
||||
* ⚠️ 必须是 **DIB + 内存 DC**，不能用 `gd::Bitmap`：GDI 在 GDI+ 位图的临时 HDC 上
|
||||
* 会**关闭 ClearType**（退化为灰度抗锯齿），列表文字因此变细、观感与正文不一致
|
||||
*（实测：整列文字丢失亚像素渲染）。DIB 内存 DC 上 ClearType 与屏幕一致。
|
||||
*/
|
||||
HDC dc = nullptr;
|
||||
HBITMAP dib = nullptr;
|
||||
std::uint64_t key = 0; /**< 内容键（不一致即重建）。 */
|
||||
int width = 0; /**< 位图宽度（= 列表宽度）。 */
|
||||
int height = 0; /**< 位图高度（= 行高）。 */
|
||||
};
|
||||
|
||||
std::vector<RowBitmapCache> m_rowBitmapCache; /**< 与 `m_rows` 同序的行位图缓存。 */
|
||||
|
||||
/**
|
||||
* @brief 行位图缓存的**数量上限**（超过即整体作废重建）。
|
||||
*
|
||||
* 一行位图 ≈ 列表宽 × 行高 × 4B（430×30×4 ≈ 51KB）。用户滚动浏览上千行时，
|
||||
* 缓存会按"画过的行下标"逐渐长大，必须有上限（这里 192 行 ≈ 10MB）。
|
||||
*/
|
||||
static constexpr std::size_t kRowBitmapCacheLimit = 192;
|
||||
std::size_t m_rowBitmapLiveCount = 0; /**< 当前持有的行位图数量。 */
|
||||
|
||||
/** @brief 行绘制正被渲染进离屏位图（此时禁止按列表矩形裁剪）。 */
|
||||
bool m_rowClipRender = false;
|
||||
|
||||
/**
|
||||
* @brief 行位图缓存渲染期间的**几何平移量**（把整行搬到"位图坐标系"）。
|
||||
*
|
||||
* ⚠️ 不能用 `gd::Graphics::TranslateTransform`：行内**文本走 GDI `DrawTextW`**，
|
||||
* 而 GDI 文本**不遵循 GDI+ 的世界变换**（`Graphics::GetHDC` 拿到的 DC 只有裁剪区），
|
||||
* 于是文字会被画到绝对坐标处、落到小位图之外（实测量产现象：行里只剩复选框/色块，
|
||||
* 文字全部消失）。因此在**几何层**平移：`RowRect` 是行内一切矩形的唯一来源，
|
||||
* 它统一减去该原点即可（`SignalBadgeRect` / ✕ / 名称框等全部自动跟随）。
|
||||
*/
|
||||
bool m_rowRenderActive = false;
|
||||
float m_rowRenderOriginX = 0.0f; /**< 位图左上角（屏幕 x）。 */
|
||||
float m_rowRenderOriginY = 0.0f; /**< 位图左上角（屏幕 y）。 */
|
||||
|
||||
/**
|
||||
* @brief 判断哪个分组行需要「悬浮」在列表顶部（返回行下标，无需悬浮时返回 -1）。
|
||||
*
|
||||
|
||||
@@ -374,6 +374,9 @@ namespace jdi
|
||||
{
|
||||
m_rows.clear();
|
||||
m_rowsDirty = false;
|
||||
// 行集合重建后行下标的含义可能变化（增删/折起展开）⇒ 行位图缓存整体作废。
|
||||
// 这同时把"不再显示的行"的位图内存还回去（缓存条目按行数增长）。
|
||||
InvalidateRowCache();
|
||||
|
||||
if (m_dataSet == nullptr || m_tab == nullptr)
|
||||
{
|
||||
@@ -500,10 +503,15 @@ namespace jdi
|
||||
// 「组名悬浮」期间把分组行钉在列表顶部绘制（见 `PaintStickyGroupRow`）：
|
||||
// 本函数是行内所有派生的唯一几何来源，因此只需在这里覆盖顶部坐标，
|
||||
// 名称框 / ✕ / 徽标等位置会自动跟随。
|
||||
//
|
||||
// ⚠️ 行位图缓存渲染时整体平移到"位图坐标系"（见 `m_rowRenderActive` 的说明：
|
||||
// GDI 文本不认 GDI+ 变换，必须在几何层平移）。
|
||||
const float renderOffsetX = m_rowRenderActive ? -m_rowRenderOriginX : 0.0f;
|
||||
const float renderOffsetY = m_rowRenderActive ? -m_rowRenderOriginY : 0.0f;
|
||||
if (m_rowYOverrideActive)
|
||||
{
|
||||
return gd::RectF(m_listRect.X, m_rowYOverrideY, m_listRect.Width,
|
||||
m_rows[static_cast<std::size_t>(row)].height);
|
||||
return gd::RectF(m_listRect.X + renderOffsetX, m_rowYOverrideY + renderOffsetY,
|
||||
m_listRect.Width, m_rows[static_cast<std::size_t>(row)].height);
|
||||
}
|
||||
|
||||
float top = m_listRect.Y - m_scrollOffset;
|
||||
@@ -516,7 +524,8 @@ namespace jdi
|
||||
{
|
||||
top -= m_rowShift[static_cast<std::size_t>(row)];
|
||||
}
|
||||
return gd::RectF(m_listRect.X, top, m_listRect.Width, m_rows[static_cast<std::size_t>(row)].height);
|
||||
return gd::RectF(m_listRect.X + renderOffsetX, top + renderOffsetY, m_listRect.Width,
|
||||
m_rows[static_cast<std::size_t>(row)].height);
|
||||
}
|
||||
|
||||
int SignalPanel::GroupLastRowIndex(int row, int rowCount) const
|
||||
|
||||
@@ -4,6 +4,8 @@
|
||||
// 分片按“职责”划分：核心（状态/布局/几何）、渲染、交互与编辑，见各文件名。
|
||||
#include "SignalPanelInternal.hpp"
|
||||
|
||||
#include <cstring>
|
||||
|
||||
namespace jdi
|
||||
{
|
||||
|
||||
@@ -186,14 +188,10 @@ namespace jdi
|
||||
g.SetClip(m_rowClipRect, gd::CombineModeIntersect);
|
||||
}
|
||||
|
||||
if (m_rows[static_cast<std::size_t>(row)].kind == RowKind::GROUP)
|
||||
{
|
||||
PaintGroupRow(g, row);
|
||||
}
|
||||
else
|
||||
{
|
||||
PaintSignalRow(g, row);
|
||||
}
|
||||
// ⚠️ 整行走**位图缓存**：分组折起/展开动画只是在平移行，
|
||||
// 行的像素一个也没变；逐行重画十来个 GDI+ 原语要 0.35ms/行
|
||||
//（一屏 35~40 行 ⇒ 每帧 12~15ms），这是"只有文字的列表却滚动卡顿"的真因。
|
||||
PaintRowCached(g, row);
|
||||
g.Restore(rowSave);
|
||||
ClearRowClip();
|
||||
}
|
||||
@@ -227,6 +225,14 @@ namespace jdi
|
||||
// 否则列表滚动时顶部那些“部分可见”的行会把组名/信号名画到筛选框上。
|
||||
// 另外，分组折起动画期间行高会连续缩小 —— 此时必须裁到**本行矩形**内，
|
||||
// 否则垂直居中的文字会溢出到相邻行上。
|
||||
//
|
||||
// ⚠️ **行位图缓存渲染时反而不能裁剪**（`m_rowClipRender`）：位图是整行内容，
|
||||
// 裁剪留到贴图时由 GDI+ 裁剪区完成（否则部分滚出上边界的行会永久丢掉顶部像素）。
|
||||
if (m_rowClipRender)
|
||||
{
|
||||
UiText(g, text, font, rect, argb, align);
|
||||
return;
|
||||
}
|
||||
UiTextClipped(g, text, font, rect, argb, align, m_rowClipActive ? m_rowClipRect : m_listRect);
|
||||
}
|
||||
|
||||
@@ -235,14 +241,251 @@ namespace jdi
|
||||
// 夹取而不是裁剪：纯色填充下两者等价，而夹取对 `UiFillRect` 的 GDI 快路径同样有效
|
||||
//（大面积不透明矩形会改走 GDI `FillRect`，它同样不受 GDI+ 裁剪约束）。
|
||||
gd::RectF clipped = rect;
|
||||
clipped.Intersect(m_rowClipActive ? m_rowClipRect : m_listRect);
|
||||
if (clipped.Width <= 0.0f || clipped.Height <= 0.0f)
|
||||
if (!m_rowClipRender)
|
||||
{
|
||||
return;
|
||||
clipped.Intersect(m_rowClipActive ? m_rowClipRect : m_listRect);
|
||||
if (clipped.Width <= 0.0f || clipped.Height <= 0.0f)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
UiFillRect(g, clipped, argb);
|
||||
}
|
||||
|
||||
void SignalPanel::InvalidateRowCache()
|
||||
{
|
||||
for (RowBitmapCache& cache : m_rowBitmapCache)
|
||||
{
|
||||
if (cache.dc != nullptr)
|
||||
{
|
||||
DeleteDC(cache.dc);
|
||||
cache.dc = nullptr;
|
||||
}
|
||||
if (cache.dib != nullptr)
|
||||
{
|
||||
DeleteObject(cache.dib);
|
||||
cache.dib = nullptr;
|
||||
}
|
||||
}
|
||||
m_rowBitmapCache.clear();
|
||||
m_rowBitmapLiveCount = 0;
|
||||
}
|
||||
|
||||
std::uint64_t SignalPanel::RowCacheKey(int row) const
|
||||
{
|
||||
std::uint64_t hash = 1469598103934665603ull;
|
||||
const auto mix = [&hash](std::uint64_t value)
|
||||
{
|
||||
hash ^= value;
|
||||
hash *= 1099511628211ull;
|
||||
};
|
||||
const auto mixFloat = [&mix](float value)
|
||||
{
|
||||
std::uint32_t bits = 0;
|
||||
std::memcpy(&bits, &value, sizeof(bits));
|
||||
mix(bits);
|
||||
};
|
||||
const auto mixText = [&mix](const std::wstring& text)
|
||||
{
|
||||
mix(text.size());
|
||||
for (const wchar_t character : text)
|
||||
{
|
||||
mix(static_cast<std::uint64_t>(character));
|
||||
}
|
||||
};
|
||||
|
||||
if (row < 0 || row >= static_cast<int>(m_rows.size()))
|
||||
{
|
||||
return hash;
|
||||
}
|
||||
const ListRow& item = m_rows[static_cast<std::size_t>(row)];
|
||||
mix(static_cast<std::uint64_t>(item.kind));
|
||||
mix(static_cast<std::uint64_t>(item.groupIndex + 1));
|
||||
mix(static_cast<std::uint64_t>(item.signalIndex + 1));
|
||||
mixFloat(item.height);
|
||||
mixFloat(m_scale);
|
||||
mix(static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(m_theme)));
|
||||
mix(static_cast<std::uint64_t>(reinterpret_cast<std::uintptr_t>(m_fonts)));
|
||||
mix(static_cast<std::uint64_t>((m_hoverRow == row) ? (static_cast<int>(m_hoverPart) + 1) : 0));
|
||||
|
||||
if (item.kind == RowKind::GROUP)
|
||||
{
|
||||
const SignalGroup* group =
|
||||
(m_dataSet != nullptr) ? m_dataSet->GroupAt(item.groupIndex) : nullptr;
|
||||
mixText((group != nullptr) ? group->name : std::wstring());
|
||||
mixText(GroupStatsText(row));
|
||||
mix(IsGroupCollapsed(item.groupIndex) ? 1ull : 0ull);
|
||||
mix(static_cast<std::uint64_t>(item.displayCount + 1));
|
||||
if (m_tab != nullptr)
|
||||
{
|
||||
mix(m_tab->GroupAllVisible(item.groupIndex) ? 1ull : 0ull);
|
||||
mix(m_tab->GroupHasVisible(item.groupIndex) ? 2ull : 0ull);
|
||||
}
|
||||
const bool editing = (m_editField == StyleEditField::GROUP_TITLE && m_editRow == row);
|
||||
mix(editing ? 1ull : 0ull);
|
||||
if (editing)
|
||||
{
|
||||
mixText(m_edit.Text());
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
const SignalRef ref{item.groupIndex, item.signalIndex};
|
||||
const SignalData* signal = (m_dataSet != nullptr) ? m_dataSet->Resolve(ref) : nullptr;
|
||||
const SignalStyle* style = StyleOf(ref);
|
||||
mixText((signal != nullptr) ? signal->name : std::wstring());
|
||||
mix((SelectedRef() == ref) ? 1ull : 0ull);
|
||||
if (style != nullptr)
|
||||
{
|
||||
mix(static_cast<std::uint64_t>(style->color));
|
||||
mixFloat(style->opacity);
|
||||
}
|
||||
if (m_tab != nullptr)
|
||||
{
|
||||
mix(m_tab->IsVisible(ref) ? 1ull : 0ull);
|
||||
mix(static_cast<std::uint64_t>(m_tab->LaneOfSignal(ref) + 1));
|
||||
}
|
||||
const bool editing = (m_editField == StyleEditField::SIGNAL_NAME && m_editRow == row);
|
||||
mix(editing ? 1ull : 0ull);
|
||||
if (editing)
|
||||
{
|
||||
mixText(m_edit.Text());
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
void SignalPanel::PaintRowCached(gd::Graphics& g, int row)
|
||||
{
|
||||
if (m_dataSet == nullptr || m_tab == nullptr || m_theme == nullptr || row < 0 ||
|
||||
row >= static_cast<int>(m_rows.size()))
|
||||
{
|
||||
return;
|
||||
}
|
||||
const gd::RectF rect = RowRect(row);
|
||||
if (rect.Height <= 0.5f)
|
||||
{
|
||||
return;
|
||||
}
|
||||
const int originX = static_cast<int>(std::floor(m_listRect.X));
|
||||
const int originY = static_cast<int>(std::floor(rect.Y));
|
||||
const int width = static_cast<int>(std::ceil(m_listRect.Width));
|
||||
const int height = static_cast<int>(std::ceil(rect.Height));
|
||||
if (width <= 0 || height <= 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
// ⚠️ 上限检查必须在**取引用之前**：`InvalidateRowCache()` 会清空容器，
|
||||
// 清理后原有引用（`RowBitmapCache&`）就悬空了。
|
||||
if (m_rowBitmapLiveCount >= kRowBitmapCacheLimit)
|
||||
{
|
||||
InvalidateRowCache();
|
||||
}
|
||||
if (m_rowBitmapCache.size() < m_rows.size())
|
||||
{
|
||||
m_rowBitmapCache.resize(m_rows.size());
|
||||
}
|
||||
RowBitmapCache& cache = m_rowBitmapCache[static_cast<std::size_t>(row)];
|
||||
const std::uint64_t key = RowCacheKey(row);
|
||||
const bool sameSize = (cache.dc != nullptr) && cache.width == width && cache.height == height;
|
||||
if (!sameSize || cache.key != key)
|
||||
{
|
||||
if (!sameSize)
|
||||
{
|
||||
if (cache.dc != nullptr)
|
||||
{
|
||||
DeleteDC(cache.dc);
|
||||
cache.dc = nullptr;
|
||||
if (m_rowBitmapLiveCount > 0)
|
||||
{
|
||||
--m_rowBitmapLiveCount;
|
||||
}
|
||||
}
|
||||
if (cache.dib != nullptr)
|
||||
{
|
||||
DeleteObject(cache.dib);
|
||||
cache.dib = nullptr;
|
||||
}
|
||||
// ⚠️ DIB + 内存 DC（而不是 `gd::Bitmap`）：GDI 在 GDI+ 位图的临时 HDC 上
|
||||
// 会关闭 ClearType，导致列表文字丢失亚像素渲染、与正文观感不一致。
|
||||
BITMAPINFO info = {};
|
||||
info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
||||
info.bmiHeader.biWidth = width;
|
||||
info.bmiHeader.biHeight = -height; // 自上而下
|
||||
info.bmiHeader.biPlanes = 1;
|
||||
info.bmiHeader.biBitCount = 32;
|
||||
info.bmiHeader.biCompression = BI_RGB;
|
||||
void* bits = nullptr;
|
||||
HDC memoryDc = CreateCompatibleDC(nullptr);
|
||||
HBITMAP dib = (memoryDc != nullptr)
|
||||
? CreateDIBSection(memoryDc, &info, DIB_RGB_COLORS, &bits, nullptr, 0)
|
||||
: nullptr;
|
||||
if (memoryDc == nullptr || dib == nullptr)
|
||||
{
|
||||
if (dib != nullptr)
|
||||
{
|
||||
DeleteObject(dib);
|
||||
}
|
||||
if (memoryDc != nullptr)
|
||||
{
|
||||
DeleteDC(memoryDc);
|
||||
}
|
||||
return;
|
||||
}
|
||||
SelectObject(memoryDc, dib);
|
||||
cache.dc = memoryDc;
|
||||
cache.dib = dib;
|
||||
cache.width = width;
|
||||
cache.height = height;
|
||||
++m_rowBitmapLiveCount;
|
||||
}
|
||||
{
|
||||
gd::Graphics rowGraphics(cache.dc);
|
||||
rowGraphics.SetSmoothingMode(gd::SmoothingModeAntiAlias);
|
||||
rowGraphics.SetPixelOffsetMode(gd::PixelOffsetModeHalf);
|
||||
rowGraphics.SetTextRenderingHint(gd::TextRenderingHintClearTypeGridFit);
|
||||
rowGraphics.Clear(ToGdiColor(m_theme->panelBg));
|
||||
// ⚠️ 用**几何平移**而不是 `TranslateTransform`（见 `m_rowRenderActive`）。
|
||||
m_rowRenderActive = true;
|
||||
m_rowRenderOriginX = static_cast<float>(originX);
|
||||
m_rowRenderOriginY = static_cast<float>(originY);
|
||||
m_rowClipRender = true;
|
||||
if (m_rows[static_cast<std::size_t>(row)].kind == RowKind::GROUP)
|
||||
{
|
||||
PaintGroupRow(rowGraphics, row);
|
||||
}
|
||||
else
|
||||
{
|
||||
PaintSignalRow(rowGraphics, row);
|
||||
}
|
||||
m_rowClipRender = false;
|
||||
m_rowRenderActive = false;
|
||||
}
|
||||
cache.key = key;
|
||||
}
|
||||
// ⚠️ 整块 1:1 搬运（不经过 GDI+ 采样/混合），字的亚像素边缘才能原样保留。
|
||||
// ⚠️ **必须自己给 DC 设裁剪**：`Graphics::GetHDC()` 交给我们的 DC 上，(a) GDI 绘制
|
||||
// 不受 GDI+ `SetClip` 的约束（这是本文件多处注释过的坑），(b) 折起/展开动画时行会
|
||||
// 滑进组名栏，必须裁到 `m_rowClipRect`。因此这里显式 `IntersectClipRect` 后再 `BitBlt`。
|
||||
const HDC targetDc = g.GetHDC();
|
||||
if (targetDc != nullptr)
|
||||
{
|
||||
const int saved = SaveDC(targetDc);
|
||||
if (saved != 0)
|
||||
{
|
||||
const gd::RectF clip = m_rowClipActive ? m_rowClipRect : m_listRect;
|
||||
IntersectClipRect(targetDc, static_cast<int>(std::floor(clip.X)),
|
||||
static_cast<int>(std::floor(clip.Y)),
|
||||
static_cast<int>(std::ceil(clip.X + clip.Width)),
|
||||
static_cast<int>(std::ceil(clip.Y + clip.Height)));
|
||||
}
|
||||
BitBlt(targetDc, originX, originY, width, height, cache.dc, 0, 0, SRCCOPY);
|
||||
if (saved != 0)
|
||||
{
|
||||
RestoreDC(targetDc, saved);
|
||||
}
|
||||
g.ReleaseHDC(targetDc);
|
||||
}
|
||||
}
|
||||
void SignalPanel::PaintGroupRow(gd::Graphics& g, int row)
|
||||
{
|
||||
if (m_dataSet == nullptr || m_tab == nullptr || row < 0 || row >= static_cast<int>(m_rows.size()))
|
||||
|
||||
@@ -6112,3 +6112,85 @@ else if (panelOnly) { /* 只回送“本帧重绘过的区域并集” */ }
|
||||
2. **任何"每帧随鼠标变化"的绘制都必须 O(光标附近)**，不能 O(整条曲线)；否则一次悬停就能把 60fps 打成 5fps。
|
||||
3. **性能与正确性判据必须是"同一次运行内的相对量"**：绝对 ms / 绝对墨迹都会随机器状态和视界内容变化而误报。
|
||||
4. 平移正确性的唯一可信判据是"与同一视界的整幅重绘对比"，而不是"与某个固定基准帧对比"。
|
||||
|
||||
---
|
||||
|
||||
## 本轮（2026-10-18 第二轮）：悬停光晕恢复"整条发光" + 信号列表卡顿真因（行位图缓存）
|
||||
|
||||
用户报告：① 上一轮的光晕修复把高亮变成了"像选区放大的长方形色块"、联动也失效；② 信号选择区
|
||||
（**只有文字**的面板）滚动/展开动画依然卡顿，反复"展开→切组复选框→收起→切回"必现。
|
||||
|
||||
### A. ① 的真因：上一轮把光晕裁到鼠标附近 ±72px
|
||||
|
||||
上一轮为了让"鼠标划过巨型信号"不卡死，把光晕塞进 `kHaloWindowHalfWidth=72` 的窗口。
|
||||
但光晕的**语义是"整条曲线一起发光"**：对满幅方波（编码器）来说，一列包络本来就跨满网格高，
|
||||
裁成一个 144px 宽 × 满高的窗口 ⇒ 屏幕上就是一个**长方形色块**，看起来像选区框。
|
||||
|
||||
本轮：`PaintSignalHaloFor` 恢复**整条**几何（包络带 `FillPath` / 折线 `DrawLines`），
|
||||
代价改由 **`PaintSignalHaloCached`** 承担：
|
||||
- 光晕的几何只取决于「信号 + 视界 + 网格几何 + 样式」，**与鼠标位置无关** ⇒ 渲染一次进离屏位图；
|
||||
- 每次贴图只做一次 `AlphaBlend`（源位图**预乘 alpha**，见下）；
|
||||
- 键与 `AcquirePolyline` 同源（`PolylineCacheEntry` 的键字段 + 样式字段），
|
||||
**不含网格屏幕位置**（滚动网格只需按新位置贴同一张位图）。
|
||||
|
||||
性能：210ms/帧（描边整条）→ **整条包络带填充一次 15ms + 每帧贴图 ~2ms**；
|
||||
`halocheck` 校验 `outsideBand=0`、`outsideLane=0`、bbox 覆盖整条曲线（不是中段方块）。
|
||||
|
||||
### B. ② 的真因有三个，都不是"面板没优化"
|
||||
|
||||
用新增探针 `panelstutter`（129 个可见网格 + 反复"展开→切组复选框→收起"）量出来的：
|
||||
|
||||
1. **面板每帧重画 ~36 行，每行 ~0.35ms**（十来个 GDI+ 原语）⇒ `panel.Paint` **24~35ms**。
|
||||
一行内容在动画期间**一个像素都没变**，变的只是 y 坐标。
|
||||
2. **动画帧里还在预热网格图层**：`WarmLaneLayersStep()` 每帧重建 1 个网格图层，
|
||||
单个 2500 万采样信号 **10~30ms** ⇒ 动画帧被硬生生拉长（用户看到的"跳帧"）。
|
||||
3. **勾选一个分组会把上百个离屏网格排进待重画队列**，随后每帧补 1 个 × 10~30ms ⇒
|
||||
**数秒的持续掉帧**（`RollWideBuffer` 对离屏网格也 `QueueLaneRebuild`）。
|
||||
|
||||
修法：
|
||||
1. **行位图缓存**（`SignalPanel::PaintRowCached`）：按"行的可见内容"做键，把整行渲染进
|
||||
离屏 DIB，命中时一次 `BitBlt` 贴出。`panel.Paint` **24~35ms → 5~6ms**。
|
||||
- ⚠️ 位图必须是 **DIB + 内存 DC**，不能用 `gd::Bitmap`：GDI 在 GDI+ 位图的临时 HDC 上
|
||||
**会关闭 ClearType**（整列文字退化成灰度抗锯齿、观感变细）。
|
||||
- ⚠️ 行内几何必须**在 `RowRect` 里平移**（`m_rowRenderActive`），不能用
|
||||
`TranslateTransform`：GDI 文本不认 GDI+ 世界变换 ⇒ 文字会画到小位图之外（实测：只剩复选框与色块）。
|
||||
- ⚠️ 渲染到行位图时**不能按列表矩形裁剪**（`m_rowClipRender`），裁剪留到贴图时的 DC 上：
|
||||
`GetHDC()` 出来的 DC **不继承 GDI+ 裁剪**，必须自己 `SaveDC + IntersectClipRect`（折起动画时
|
||||
行要滑进组名栏、不许画到组名上）。
|
||||
- 缓存数量上限 192 行（≈10MB），超过即整体作废。
|
||||
- 静态画面**逐像素一致**（面板区域 54/275200 像素不同，最大差 75 —— 滚动条滑块抗锯齿）。
|
||||
2. **UI 动画期间不预热网格图层**（`PlotView::SetAnimationBusy`，由 `Application::Render` 传入）：
|
||||
预热被"推迟"而不是取消（队列保留），动画结束后按既有预算继续。
|
||||
3. **待重画队列只保留可视 + 预取带内的网格**（`RenderPendingLaneRebuilds` 丢弃离屏项）；
|
||||
`RollWideBuffer` 也不再登记离屏网格 —— 它们真正进入视区时会按新视界重新登记。
|
||||
|
||||
实测（`panelstutter`，同一台同一次运行）：展开动画 **p50 35ms → 13ms**、收起 **33ms → 13ms**、
|
||||
面板绘制 **24~35ms → 5~6ms**、动画帧里"重建网格图层"次数 **56 → 0**。
|
||||
|
||||
### C. 试过但放弃的两条路（避免以后重走）
|
||||
|
||||
- **`ExtTextOutW` 替代 `DrawTextW`**：约快 2~4 倍，但**光栅化结果不同**（面板区域 10% 像素差异、
|
||||
亚像素边缘差 1px）⇒ 全体界面文字观感变化，放弃。
|
||||
- **用 `gd::Bitmap` 做行位图**：文字丢失 ClearType（见 B.1）。
|
||||
|
||||
### D. 验证（全部离屏，不占用鼠标/键盘/屏幕）
|
||||
|
||||
- 新增 `panelstutter`（8/8）：展开/收起动画帧不重建网格图层、动画 p50 ≤ idle+12ms、
|
||||
行悬停仍会重绘该行（行缓存随悬停失效）。
|
||||
- 新增 `halocheck`（16/16）：悬停必命中（60/60 采样位置）、光晕沿整条曲线且贴合带宽、
|
||||
列表行悬停联动、单信号满高场景耗时受控。
|
||||
- 回归：`verify` 49/49、`panelanim` 158/158、`hoverdrag` 20/20、`gridanim` 93/93、
|
||||
`lanescroll` 23/23、`datacheck` 69/69、`edgecheck` 46/46、`errcheck` 19/19、
|
||||
`panflash` 19/19、`stress` 6/6。
|
||||
- `make release` / `make debug` 零警告（`TARGET_FILE_NAME=TargetCheck/TargetCheckD`）。
|
||||
|
||||
### E. 教训（新增规则）
|
||||
|
||||
1. **"高亮提示"的语义是"整条曲线发光"**：任何把高亮裁成"鼠标附近一段"的做法，在满幅信号上
|
||||
都会退化成"长方形色块"（用户一眼就看出不对）。性能要用**缓存**解决，不能改变语义。
|
||||
2. **GDI 文本的三种"隐形陷阱"**：① 不认 GDI+ 世界变换（要平移几何）；② 不认 GDI+ 裁剪区
|
||||
（要自己 `IntersectClipRect`）；③ 在 GDI+ 位图的临时 HDC 上**关闭 ClearType**
|
||||
（要改用 DIB + 内存 DC）。
|
||||
3. **"面板只有文字却卡顿"多半不是文字本身的锅**：先量"每行成本 × 可见行数"，
|
||||
再量"这一帧是否顺带在做绘图区的重活"（图层预热 / 队列排空）。
|
||||
4. **动画帧里绝不做可延迟的整帧级工作**（图层重建、队列排空）；这类工作一律推迟到动画之后。
|
||||
@@ -52,6 +52,7 @@ WIN_RES_COMPLIER = windres
|
||||
LIB_LINK = \
|
||||
-lgdi32 \
|
||||
-lgdiplus \
|
||||
-lmsimg32 \
|
||||
-lcomdlg32 \
|
||||
-ld3d11 \
|
||||
-ldwmapi \
|
||||
|
||||
+64
-43
@@ -123,8 +123,64 @@ namespace jdi
|
||||
};
|
||||
/** 上限保护：超过时整体清空（缓存只是加速手段，清空后重新填充即可）。 */
|
||||
constexpr std::size_t kMeasureCacheLimit = 4096;
|
||||
std::unordered_map<MeasureKey, float, MeasureKeyHash> g_measureCache;
|
||||
|
||||
/** 文本的像素宽度与字符单元高度（后者与 `DT_VCENTER` 的居中口径一致）。 */
|
||||
struct TextExtent
|
||||
{
|
||||
float width = 0.0f; /**< 像素宽度。 */
|
||||
float height = 0.0f; /**< 字符单元高度。 */
|
||||
};
|
||||
|
||||
std::unordered_map<MeasureKey, TextExtent, MeasureKeyHash> g_measureCache;
|
||||
std::mutex g_measureMutex;
|
||||
|
||||
/**
|
||||
* @brief 取文本的宽 / 高（带缓存）。
|
||||
*
|
||||
* ⚠️ 必须走 GDI（`GetDC` + `GetTextExtentPoint32W` + `ReleaseDC`），单次约 10µs；
|
||||
* 而布局与绘制每帧会把同一批字符串**重复测量成百上千次**，因此按 (字体, 文本) 缓存。
|
||||
* 高度也一并缓存：`DrawUiText` 的快速路径要用它做垂直居中（见那里的说明）。
|
||||
*/
|
||||
TextExtent MeasureText(HFONT font, const std::wstring& text)
|
||||
{
|
||||
if (text.empty() || font == nullptr)
|
||||
{
|
||||
return TextExtent();
|
||||
}
|
||||
const MeasureKey key{font, text};
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(g_measureMutex);
|
||||
const auto found = g_measureCache.find(key);
|
||||
if (found != g_measureCache.end())
|
||||
{
|
||||
return found->second;
|
||||
}
|
||||
}
|
||||
|
||||
HDC hdc = GetDC(nullptr);
|
||||
if (hdc == nullptr)
|
||||
{
|
||||
return TextExtent();
|
||||
}
|
||||
HGDIOBJ oldFont = SelectObject(hdc, font);
|
||||
SIZE size = {};
|
||||
GetTextExtentPoint32W(hdc, text.c_str(), static_cast<int>(text.size()), &size);
|
||||
SelectObject(hdc, oldFont);
|
||||
ReleaseDC(nullptr, hdc);
|
||||
|
||||
TextExtent extent;
|
||||
extent.width = static_cast<float>(size.cx);
|
||||
extent.height = static_cast<float>(size.cy);
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(g_measureMutex);
|
||||
if (g_measureCache.size() >= kMeasureCacheLimit)
|
||||
{
|
||||
g_measureCache.clear();
|
||||
}
|
||||
g_measureCache.emplace(key, extent);
|
||||
}
|
||||
return extent;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void UiClearMeasureCache()
|
||||
@@ -413,6 +469,10 @@ namespace jdi
|
||||
rc.right = static_cast<LONG>(std::ceil(rect.X + rect.Width));
|
||||
rc.bottom = static_cast<LONG>(std::ceil(rect.Y + rect.Height));
|
||||
|
||||
// ⚠️ 这里必须继续用 `DrawTextW`：试过改用 `ExtTextOutW` 的"快速路径"（约快 2~4 倍），
|
||||
// 但同一段文字的**光栅化结果并不相同**（实测面板区域 10% 的像素有差异，
|
||||
// 亚像素边缘与基线差 1px）—— 全体界面文字观感都会变，因此放弃。
|
||||
// 列表卡顿改由"行位图缓存 + 动画期间不预热网格图层"解决（见 `SignalPanel::PaintRowCached`）。
|
||||
UINT flags = DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_END_ELLIPSIS;
|
||||
switch (align)
|
||||
{
|
||||
@@ -455,48 +515,9 @@ namespace jdi
|
||||
|
||||
float UiMeasureTextWidth(HFONT font, const std::wstring& text)
|
||||
{
|
||||
if (text.empty() || font == nullptr)
|
||||
{
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
// 记忆化：文本宽度只能走 GDI（GetDC + GetTextExtentPoint32W + ReleaseDC），
|
||||
// 单次约 10µs；而布局代码每帧会把同一批字符串**重复测量成百上千次**——
|
||||
// 例如浮动面板的几何是按「网格数 × 面板种类」反复重算的（5 网格 × 4 类 = 20 次，
|
||||
// 每次十来个字符串），实测光这一项就占 3ms 以上。字体与文本都相同的测量结果
|
||||
// 必然一致，因此按 (字体, 文本) 做一层缓存；字体被重建时由 `UiClearMeasureCache` 作废。
|
||||
const MeasureKey key{font, text};
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(g_measureMutex);
|
||||
const auto found = g_measureCache.find(key);
|
||||
if (found != g_measureCache.end())
|
||||
{
|
||||
return found->second;
|
||||
}
|
||||
}
|
||||
|
||||
HDC hdc = GetDC(nullptr);
|
||||
if (hdc == nullptr)
|
||||
{
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
HGDIOBJ oldFont = SelectObject(hdc, font);
|
||||
SIZE size = {};
|
||||
GetTextExtentPoint32W(hdc, text.c_str(), static_cast<int>(text.size()), &size);
|
||||
SelectObject(hdc, oldFont);
|
||||
ReleaseDC(nullptr, hdc);
|
||||
|
||||
const float width = static_cast<float>(size.cx);
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(g_measureMutex);
|
||||
if (g_measureCache.size() >= kMeasureCacheLimit)
|
||||
{
|
||||
g_measureCache.clear();
|
||||
}
|
||||
g_measureCache.emplace(key, width);
|
||||
}
|
||||
return width;
|
||||
// 记忆化（键 = 字体 + 文本，值 = 宽 / 高）：布局代码每帧会把同一批字符串
|
||||
// **重复测量成百上千次**，而 `GetTextExtentPoint32W` 单次约 10µs。
|
||||
return MeasureText(font, text).width;
|
||||
}
|
||||
|
||||
std::wstring UiEllipsize(const std::wstring& text, HFONT font, float maxWidth)
|
||||
|
||||
Reference in new issue
Block a user