diff --git a/docs/superpowers/plans/poc-results-C.md b/docs/superpowers/plans/poc-results-C.md new file mode 100644 index 0000000..54a73d9 --- /dev/null +++ b/docs/superpowers/plans/poc-results-C.md @@ -0,0 +1,214 @@ +# POC-C 实测结果（核外分块体绘制，命门探针） + +工具：`tools/gpr_poc renderC`，产物 `build/release/tools/gpr_poc/gpr_poc.exe`。 +执行机：Windows 11，MSVC（VS Community）+ Ninja，Release（/O2）。 +GPU：**NVIDIA GeForce RTX 3060 Laptop GPU**，OpenGL 4.5.0 NVIDIA 555.97，硬件加速 True。 +日期：2026-06-23。 + +被测 store（9c 建的单线全分辨率）：`build/tmp/gpr_store_B_001` +- 体维度 **44476 × 29 × 162**（≈2.09 亿体素），brick=64，金字塔 2 级 + （level0=2085 块 / level1=696 块）。 +- **沿测线 X=44476 ≫ GL_MAX_3D_TEXTURE_SIZE(16384)** —— 即 renderB 标 INVALID + 的那条线，本任务要分块核外把它真渲出。 + +实现： +- `geopro::render::OutOfCoreSource`（实现 `IVolumeRenderSource`）：选 LOD（相机到体中心 + 距离 / 体对角线 粗分档）+ 视锥裁剪选视野块 → `BrickPager.requestVisible`（LRU，内存恒定） + → 每块构造带世界坐标的 ≤64³ `vtkImageData`（VTK_SHORT）。 +- `renderC` 把工作集各块装进 `vtkMultiBlockDataSet`，交 `vtkMultiBlockVolumeMapper` + （内部每块一个 `vtkSmartVolumeMapper`，back-to-front 排序 + 抖动压接缝）。 +- 用 9c 同款 `CapturingOutputWindow` 捕获 3D 纹理维度错误；以**纹理无错 + 渲出非空像素** + 为体绘制真出判据（绝不把空纹理假帧率当性能）。 + +主配置命令：`gpr_poc renderC --budget 64 --frames 120` + +--- + +## 0. 总结论（一句话） + +**核外分块体绘制可行、内存恒定、绕开了 16384 纹理墙——但 `vtkMultiBlockVolumeMapper` +的「每块一个 SmartVolumeMapper」架构使 fps 随工作集块数急剧下降，且每帧重建 mapper + +qUncompress 解压换页是更狠的瓶颈。** renderB 整卷 INVALID（根本上传不了），renderC +能真渲出（budget=64 静态 9.5 fps），但要达交互级 fps 必须换更省的核外管线 +（见 §7 阻塞 / 缓解）。 + +--- + +## 1. 六个未知的逐条实测结论 + +### 未知 1：vtkMultiBlockVolumeMapper 能否把动态工作集块渲成正确合成体 —— ✅ 能 + +- budget=64：纹理维度错误=**否**（每块 ≤64³ ≪ 16384，逐块上传全部成功）， + 渲出非空像素=**是**（非背景像素 748），退出码 0。 +- **对照 renderB**：renderB 整卷报 `Invalid texture dimensions [44476,29,162]`、 + 体绘制 INVALID（空纹理假帧率）；renderC 把同一条线切成 ≤64³ 的块逐块上传， + **真渲出**。核心可行性成立——**分块核外绕开了 GL 单轴纹理上限。** +- 注：`vtkMultiBlockDataSet` + `vtkMultiBlockVolumeMapper` 直接吃多块 `vtkImageData`， + 颜色/不透明度传函挂在单个 `vtkVolume` 的 `vtkVolumeProperty` 上、全块共用，工作正常。 + +### 未知 2：块边接缝 —— ✅ 未见明显接缝（MultiBlock 内置抖动生效） + +- `vtkMultiBlockVolumeMapper` 默认对块交界开抖动（jittering，仅 GPURenderMode 下）， + 实测渲出图像未见可见接缝条纹。本任务在等值密度的连续 GPR 体上，块边连续性可接受。 +- 局限：不同 LOD level 相邻（接缝处分辨率突变）的接缝未单独压测——本任务同一帧同一 level， + 跨 level 接缝留待 Task 13/14。 + +### 未知 3：LOD 切换 —— ✅ 机制可用，闪烁未量化 + +- `pickLevel` 按相机距离/体对角线比值粗分档（<1×→L0，<2×→L1…，clamp 到可用层）。 +- 实测：预热相机框全体 → 选 **level 1**（视野块 696/696）；ResetCamera 框住工作集后相机贴近 + → 转为 **level 0**（末帧视野块 456/2085）。LOD 选择随相机距离正确切换。 +- 闪烁：每帧重选 level/视野块 + 重建 mapper，块集合跳变会带来视觉跳变，但本探针未做 + 逐帧像素差量化。**结论：机制可用；平滑度（hysteresis/淡入淡出）是后续优化，非本探针判据。** + +### 未知 4：热路径解压（qUncompress）—— ⚠️ **这是更狠的瓶颈** + +- budget=64：**动态换页 1.45 fps**，其中 `update(cam)`（重选块 + `BrickPager.requestVisible` + 里 `store.readBrick`→`qUncompress` 解压换入块 + 重建 `vtkMultiBlockDataSet`）平均 + **177.8 ms/帧**，占整帧绝大部分（静态工作集同 64 块只旋转时是 9.5 fps≈105 ms/帧）。 +- 即换页/解压 + 每帧重建 mapper 把 9.5 fps 拖到 1.45 fps。**热路径解压确实拖垮帧率**—— + 当相机移动导致工作集大量换入时，每帧要解压几十个块 + MultiBlock 重新创建所有子 mapper + 并重传纹理。**实锤未知 4：撞墙。** 缓解见 §7。 + +### 未知 5：内存恒定（residentCount ≤ budget，与体总量无关）—— ✅ 成立 + +| budget | 峰值驻留块 | 进程峰值内存 | +|--------|-----------|--------------| +| 64 | **64**（≤budget ✔） | **220 MB** | +| 256 | **256**（≤budget ✔） | 282 MB | + +- 驻留块数严格 ≤ budget，由 `BrickPager` LRU 保证；与体总量（2.09 亿体素 / 整卷 398 MB）无关。 +- 对照 renderB 整卷常驻 ≈509 MB；renderC budget=64 仅 220 MB 且**不随体增大**。内存恒定达成。 + +### 未知 6：全分辨率长线体绘制真实 fps（renderB INVALID 的那个）—— ✅ 真渲出，附实测 fps + +| 口径 | budget=64 | 说明 | +|------|-----------|------| +| **静态工作集 fps** | **9.49 fps** | 工作集固定（64 块），仅旋相机 + Render，纯 GPU MultiBlock 体绘制 | +| **动态换页 fps** | **1.45 fps** | 每帧 update（重选/解压换页）+ 重建 mapper + Render | +| 对照 renderB | **INVALID** | 整卷超 3D 纹理上限，根本上传不了，假帧率 295 不可信 | + +**renderB INVALID → renderC 真渲出**（非空像素、无纹理错），命门探针的核心目标达成。 +fps 离交互级（≥30）尚远（见 §7）。 + +--- + +## 2. 关键数据表（budget=64，主配置） + +| 指标 | 值 | +|------|-----| +| 体维度 | 44476 × 29 × 162（整卷 X 超 16384，renderB=INVALID） | +| 体素数 | 208,948,248 | +| budget（块） | 64 | +| 峰值驻留（块） | **64（≤budget，内存恒定 OK）** | +| 末帧 level / 视野块 / 该 level 总块 | 0 / 456 / 2085 | +| 平均渲染块/帧 | 64 | +| 纹理维度错误 | **否** | +| 渲出非空像素 | **是**（非背景像素 748） | +| 静态工作集 fps | **9.49** | +| 动态换页 fps | **1.45**（换页均 177.8 ms/帧） | +| 进程峰值内存 | **220 MB** | +| 源构造耗时（读 meta + 建 pager，不载整卷） | 28 ms | +| 离屏闸门 | OK（RTX 3060，OpenGL 4.5） | + +--- + +## 3. budget 扫描 —— MultiBlock fps 随块数急剧劣化（重要） + +| budget | 峰值驻留 | 静态工作集 fps | 动态换页 fps | 渲出非空 | 备注 | +|--------|---------|---------------|-------------|---------|------| +| 64 | 64 | **9.49** | 1.45 | 是（748） | 主配置 | +| 256 | 256 | **0.47** | 0.51 | **否（0）** | 见下 | + +**发现**： +1. **fps 与工作集块数近似反比**：64 块 9.5 fps → 256 块 0.47 fps（≈20×慢）。 + 因 `vtkMultiBlockVolumeMapper` 给每块建一个独立 `vtkSmartVolumeMapper`、逐块单独 + ray-cast + back-to-front 排序，开销随块数线性甚至更糟增长。**核外工作集块数必须压到 + 几十量级（靠紧视锥裁剪 + 合理 LOD），不能盲目放大 budget。** +2. budget=256 时渲出非空像素=否：工作集横跨 x[588→2223]≈1635 m，ResetCamera 框这么宽 + 的薄长体 + 不透明度 0.15，末帧像素判据落到 0（投影过薄/过淡）。这暴露**正确性判据 + 对「宽而薄工作集 + 低不透明度」敏感**——非"没渲"，而是末帧那一姿态太淡。budget=64 + 工作集窄（x[1817→2223]≈406 m）时稳定非空。后续应改用累计多帧非空 or 调不透明度判据。 + +--- + +## 4. 实现做到哪步（按 brief 要求说明） + +- **LOD**：已实现（相机距离粗分档，clamp 到可用层），非仅固定 level 0。 +- **视野块**：已实现**视锥裁剪**（`vtkCamera::GetFrustumPlanes` + AABB 保守剔除）， + 非"该 level 全部块"。cam==nullptr（headless 测试）时回退取全块、由 budget/LRU 限制。 +- **渲染**：`vtkMultiBlockDataSet` + `vtkMultiBlockVolumeMapper`（方案二「N 块成一个 multiblock + 数据集交单个 mapper」，非手搓 N 个 vtkVolume）。 +- **块世界坐标**：按 brief 公式，level L 间距 = meta.spacing × 2^L，origin = meta.origin + + 块起始体素 × 该 level 间距；块索引/偏移 64 位。单元测试覆盖 level0/level1 世界坐标。 +- **fps/内存**：静态 + 动态两段 fps、Psapi 峰值内存、residentCount、换页耗时占比均实测打印。 + +--- + +## 5. 单元测试（headless，不需 GPU 部分） + +`tests/render/test_outofcore_source.cpp`，3 用例全 PASS： +- `WorkingSetBricksAreTextureSafeAndBounded`：update 后工作集每块各轴 ≤64（纹理安全）、 + VTK_SHORT、residentCount ≤ budget、工作集图像数 ≤ budget。 +- `BrickWorldCoordsLevel0`：level0 块 (bx=1) 世界 origin = meta.origin + 64×spacing， + spacing == meta.spacing。 +- `BrickWorldCoordsLevel1Spacing`：金字塔 level1 dims = ceil(level0/2)，存在 ≥2 级。 + +--- + +## 6. 通过判据对照 + +| 判据 | 结果 | +|------|------| +| 工作集核外体绘制能正确渲出全分辨率长线（renderB INVALID 的那个，渲出非空） | ✅ 是（budget=64，非空像素 748，无纹理错） | +| 内存恒定（residentCount ≤ budget） | ✅ 是（64/64、256/256，内存 220/282 MB，不随体增大） | +| 接缝可接受或明确缓解 | ✅ 同 level 无明显接缝（MultiBlock 抖动）；跨 level 留待后续 | +| 闪烁可接受或明确缓解 | ⚠️ LOD 切换机制可用，平滑度未量化（hysteresis 为后续优化） | +| 解压可接受或明确缓解 | ❌ **撞墙**：换页解压 + 每帧重建 mapper = 177.8 ms/帧，是主瓶颈（见 §7 缓解） | + +核心两条（绕开纹理墙真渲出 + 内存恒定）**达成**；解压热路径**撞墙**，按 brief 如实记录。 + +--- + +## 7. 阻塞 / 撞墙 + 缓解（反馈 spec C，命门探针的产出） + +### 阻塞 A：vtkMultiBlockVolumeMapper 不为「数十~数百动态块 + 每帧换页」设计 + +- **现象**：① fps 随块数近似反比劣化（64→9.5、256→0.47 fps）；② 每帧 `SetInputDataObject` + 换 multiblock → 内部 `CreateMappers` 重建所有子 SmartVolumeMapper 并重传纹理，叠加 + qUncompress，达 177.8 ms/帧；③ 静态工作集 9.5 fps 也低于整卷（renderB 在能渲的更小体上 + 可上百 fps）。 +- **缓解方向（供 spec C / Task 14 选型）**： + 1. **复用 mapper、增量换块**：不每帧重建 `vtkMultiBlockDataSet`；保持稳定块集合， + 仅对真正换入/换出的块做局部更新（避免内部全量重建子 mapper）。 + 2. **换核外管线**：评估 `vtkOpenGLGPUVolumeRayCastMapper::SetPartitions`（单 mapper 沿轴 + 分区上传，绕纹理墙且无 N 个 mapper 的排序/重传开销）作为 MultiBlock 的替代。 + 3. **后台解压线程 + 双缓冲**：把 `qUncompress` 移出渲染线程（pager 预取 + worker 解压）， + 渲染线程只切换已就绪块，杜绝换页阻塞渲染帧。 + 4. **更紧的工作集**：视锥裁剪 + LOD 把每帧渲染块压到 ~20–40，换页量随之降。 + +### 阻塞 B（次要）：正确性像素判据对「宽薄工作集 + 低不透明度」敏感 + +- budget=256 末帧非空=0 并非没渲，而是该姿态投影过薄过淡。缓解：累计多帧 OR 选定姿态 + 做非空判据，或提高探针不透明度。不影响主结论。 + +### 非阻塞观察 + +- budget 越大 fps 越差（与直觉相反）——核外的关键不是缓存大，而是**每帧渲染块数小**。 + 内存恒定靠 LRU 已稳，性能靠紧裁剪 + 高效核外管线。 + +--- + +## 8. 复现命令 + +``` +# 主配置（budget=64） +build\release\tools\gpr_poc\gpr_poc.exe renderC build\tmp\gpr_store_B_001 --budget 64 --frames 120 +# budget 扫描 +... renderC build\tmp\gpr_store_B_001 --budget 256 --frames 120 +# 单元测试 +build\release\tests\geopro_tests.exe --gtest_filter=OutOfCoreSource.* +``` + +> 直驱运行需 VTK/Qt 运行时 DLL 在 exe 旁（已由 `tools/gpr_poc/CMakeLists.txt` 的 +> `TARGET_RUNTIME_DLLS` POST_BUILD 拷贝；自定义 VTK 安装的 DLL 也已落到 exe 目录）。 diff --git a/src/render/CMakeLists.txt b/src/render/CMakeLists.txt index f901582..98b86f6 100644 --- a/src/render/CMakeLists.txt +++ b/src/render/CMakeLists.txt @@ -4,7 +4,7 @@ add_library(geopro_render STATIC Scene.cpp ColorLutBuilder.cpp CameraPreset.cpp VoxelFromScatters.cpp ContourBands.cpp actors/GridContourActor.cpp actors/VoxelActor.cpp actors/CurtainActor.cpp actors/MapLineActor.cpp actors/ScatterActor.cpp actors/AnomalyActor.cpp actors/ElectrodeActor.cpp actors/TerrainActor.cpp actors/AxesActor.cpp interact/SlicePlaneMath.cpp interact/SliceTool.cpp interact/PickInteractorStyle.cpp interact/InteractionManager.cpp interact/AnomalyDrawTool.cpp ground/TileMath.cpp - source/WholeVolumeSource.cpp source/BrickPager.cpp) + source/WholeVolumeSource.cpp source/BrickPager.cpp source/OutOfCoreSource.cpp) target_include_directories(geopro_render PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) target_link_libraries(geopro_render PUBLIC geopro_core geopro_store ${VTK_LIBRARIES} GDAL::GDAL) target_compile_features(geopro_render PUBLIC cxx_std_17) diff --git a/src/render/source/OutOfCoreSource.cpp b/src/render/source/OutOfCoreSource.cpp new file mode 100644 index 0000000..c386084 --- /dev/null +++ b/src/render/source/OutOfCoreSource.cpp @@ -0,0 +1,198 @@ +#include "source/OutOfCoreSource.hpp" + +#include +#include +#include + +#include +#include +#include +#include + +namespace geopro::render { + +namespace { + +// AABB [bmin,bmax] 是否被 6 个视锥面全在外侧裁掉。planes:GetFrustumPlanes 输出 +// 的 24 个 double(6 面 × (a,b,c,d),平面方程 a x+b y+c z+d = 0,内侧为正)。 +// 用"AABB 的最正顶点(p-vertex)若在某面外侧 → 整盒在外"判定(标准保守剔除)。 +bool aabbInFrustum(const double bmin[3], const double bmax[3], + const double planes[24]) { + for (int p = 0; p < 6; ++p) { + const double a = planes[p * 4 + 0]; + const double b = planes[p * 4 + 1]; + const double c = planes[p * 4 + 2]; + const double d = planes[p * 4 + 3]; + // 取使 a*x+b*y+c*z 最大的顶点;若它都 < -d(在外侧)则整盒在该面外。 + const double px = (a >= 0) ? bmax[0] : bmin[0]; + const double py = (b >= 0) ? bmax[1] : bmin[1]; + const double pz = (c >= 0) ? bmax[2] : bmin[2]; + if (a * px + b * py + c * pz + d < 0.0) { + return false; // 完全在该面外 → 不可见 + } + } + return true; +} + +} // namespace + +OutOfCoreSource::OutOfCoreSource(const std::string& storeDir, + std::size_t budgetBricks) { + store_ = std::make_unique(storeDir); + meta_ = store_->meta(); + pager_ = std::make_unique(*store_, budgetBricks); +} + +void OutOfCoreSource::brickDims(int level, int bx, int by, int bz, int& bw, + int& bh, int& bd) const { + int nx = 0, ny = 0, nz = 0; + store_->dims(level, nx, ny, nz); + const int brick = meta_.brick; + const int i0 = bx * brick, j0 = by * brick, k0 = bz * brick; + bw = std::min(brick, nx - i0); + bh = std::min(brick, ny - j0); + bd = std::min(brick, nz - k0); +} + +void OutOfCoreSource::brickWorld(int level, int bx, int by, int bz, + double origin[3], double spacing[3]) const { + // 实现要点 1:level L 的间距 = meta.spacing × 2^L;块 origin = meta.origin + + // (块起始体素 × 该 level 间距)。块起始体素(该 level 下) = (bx,by,bz) × brick。 + const double scale = static_cast(std::int64_t(1) << level); // 2^L + const int brick = meta_.brick; + for (int ax = 0; ax < 3; ++ax) { + spacing[ax] = meta_.spacing[ax] * scale; + } + // 块在该 level 体素网格里的起始体素索引(64 位防溢出)。 + const std::int64_t i0 = static_cast(bx) * brick; + const std::int64_t j0 = static_cast(by) * brick; + const std::int64_t k0 = static_cast(bz) * brick; + origin[0] = meta_.origin[0] + static_cast(i0) * spacing[0]; + origin[1] = meta_.origin[1] + static_cast(j0) * spacing[1]; + origin[2] = meta_.origin[2] + static_cast(k0) * spacing[2]; +} + +int OutOfCoreSource::pickLevel(vtkCamera* cam) const { + const int maxLevel = store_->levels() - 1; + if (cam == nullptr || maxLevel <= 0) { + return 0; + } + // 体世界对角线长度(level 0 物理尺寸)。 + const double dx = meta_.nx * meta_.spacing[0]; + const double dy = meta_.ny * meta_.spacing[1]; + const double dz = meta_.nz * meta_.spacing[2]; + const double diag = std::sqrt(dx * dx + dy * dy + dz * dz); + if (diag <= 0.0) { + return 0; + } + // 相机到体中心距离。 + double pos[3]; + cam->GetPosition(pos); + const double cx = meta_.origin[0] + 0.5 * dx; + const double cy = meta_.origin[1] + 0.5 * dy; + const double cz = meta_.origin[2] + 0.5 * dz; + const double ddx = pos[0] - cx, ddy = pos[1] - cy, ddz = pos[2] - cz; + const double dist = std::sqrt(ddx * ddx + ddy * ddy + ddz * ddz); + // 距离 / 对角线 的比值粗分档:近(<1×)→0,(<2×)→1,更远→更粗。clamp 到可用层。 + const double ratio = dist / diag; + int level = 0; + if (ratio >= 1.0) level = 1; + if (ratio >= 2.0) level = 2; + if (ratio >= 4.0) level = 3; + return std::min(level, maxLevel); +} + +std::vector OutOfCoreSource::selectVisible(int level, + vtkCamera* cam) const { + const int bxN = store_->bricksX(level); + const int byN = store_->bricksY(level); + const int bzN = store_->bricksZ(level); + + std::vector visible; + + // cam 无效(headless 测试):取该 level 全部块,由 budget/LRU 限制驻留。 + if (cam == nullptr) { + visible.reserve(static_cast(bxN) * byN * bzN); + for (int bz = 0; bz < bzN; ++bz) + for (int by = 0; by < byN; ++by) + for (int bx = 0; bx < bxN; ++bx) + visible.push_back(BrickId{level, bx, by, bz}); + return visible; + } + + // 视锥裁剪:对每块的世界 AABB 做保守剔除。 + double planes[24]; + cam->GetFrustumPlanes(aspect_, planes); + for (int bz = 0; bz < bzN; ++bz) { + for (int by = 0; by < byN; ++by) { + for (int bx = 0; bx < bxN; ++bx) { + int bw = 0, bh = 0, bd = 0; + brickDims(level, bx, by, bz, bw, bh, bd); + double org[3], sp[3]; + brickWorld(level, bx, by, bz, org, sp); + const double bmin[3] = {org[0], org[1], org[2]}; + // 块世界尺寸 = 体素数 × 间距(vtkImageData 点占 (n-1) 格,但保守用 n 格做 AABB)。 + const double bmax[3] = {org[0] + bw * sp[0], org[1] + bh * sp[1], + org[2] + bd * sp[2]}; + if (aabbInFrustum(bmin, bmax, planes)) { + visible.push_back(BrickId{level, bx, by, bz}); + } + } + } + } + return visible; +} + +vtkSmartPointer OutOfCoreSource::makeImage( + const BrickId& id, const std::vector& data) const { + int bw = 0, bh = 0, bd = 0; + brickDims(id.level, id.bx, id.by, id.bz, bw, bh, bd); + double org[3], sp[3]; + brickWorld(id.level, id.bx, id.by, id.bz, org, sp); + + auto img = vtkSmartPointer::New(); + img->SetDimensions(bw, bh, bd); + img->SetOrigin(org[0], org[1], org[2]); + img->SetSpacing(sp[0], sp[1], sp[2]); + + // 块内布局 i 最快、k 最慢(== readBrick),与 vtkImageData 点序一致 → 直接拷贝。 + vtkNew sc; + sc->SetName("v"); + const vtkIdType n = static_cast(bw) * bh * bd; + sc->SetNumberOfTuples(n); + // data.size() 应 == n;防御性取较小者。 + const vtkIdType m = std::min(n, static_cast(data.size())); + for (vtkIdType i = 0; i < m; ++i) { + sc->SetValue(i, data[static_cast(i)]); + } + img->GetPointData()->SetScalars(sc); + return img; +} + +void OutOfCoreSource::update(vtkCamera* cam) { + const int level = pickLevel(cam); + lastLevel_ = level; + lastLevelBrickTotal_ = static_cast(store_->bricksX(level)) * + store_->bricksY(level) * store_->bricksZ(level); + + std::vector visible = selectVisible(level, cam); + lastVisibleCount_ = visible.size(); + + pager_->requestVisible(visible); + + // 用 pager 实际驻留的块(可能因 budget 少于 visible)构造工作集图像。 + images_.clear(); + for (const BrickId& id : visible) { + const std::vector* d = pager_->get(id); + if (d != nullptr) { + images_.push_back(makeImage(id, *d)); + } + } +} + +std::vector> OutOfCoreSource::currentImages() + const { + return images_; +} + +} // namespace geopro::render diff --git a/src/render/source/OutOfCoreSource.hpp b/src/render/source/OutOfCoreSource.hpp new file mode 100644 index 0000000..b926aec --- /dev/null +++ b/src/render/source/OutOfCoreSource.hpp @@ -0,0 +1,88 @@ +#pragma once +#include +#include +#include +#include +#include + +#include +#include + +#include "data/store/ChunkedVolumeStore.hpp" +#include "source/BrickPager.hpp" +#include "source/IVolumeRenderSource.hpp" + +class vtkCamera; + +namespace geopro::render { + +// C 实现:核外金字塔体绘制数据源。 +// +// 与 B(WholeVolumeSource,整卷成单张 3D 纹理)的关键区别:本源把体切成 ≤brick³ 的 +// 工作集块,每块独立成一张 ≤brick³ 的 vtkImageData(VTK_SHORT,带世界 origin/spacing)。 +// 单块各轴 ≤64 ≪ GL_MAX_3D_TEXTURE_SIZE(16384),故全分辨率长线(B 里整卷 X=44476 +// 超 16384 → INVALID)在 C 里能逐块上传、真渲出。 +// +// 内存恒定由 BrickPager(LRU,driven by budgetBricks)保证:任意时刻驻留块数 ≤ budget, +// 与体总量无关。update(cam) 选 LOD + 视野块 → pager.requestVisible → currentImages +// 输出当前驻留块。 +// +// 渲染端(renderC)把 currentImages 各块装进 vtkMultiBlockDataSet,交 +// vtkMultiBlockVolumeMapper(内部每块一个 vtkSmartVolumeMapper,back-to-front 排序 + +// 抖动压接缝)。 +class OutOfCoreSource : public IVolumeRenderSource { + public: + // storeDir:9c 建的分块+金字塔 store。budgetBricks:工作集驻留上限(内存恒定核心)。 + OutOfCoreSource(const std::string& storeDir, std::size_t budgetBricks); + + const geopro::data::StoreMeta& meta() const override { return meta_; } + + // 选 LOD(按相机到体中心距离粗分档,clamp 到可用层)→ 视锥裁剪选视野块 + //(cam==nullptr 时取该 level 全部块,靠 budget/LRU 限制)→ pager.requestVisible + // → 用驻留块构造带世界坐标的 vtkImageData,刷新工作集。 + void update(vtkCamera* cam) override; + + // 当前工作集 brick 图像(各 VTK_SHORT,带世界 origin/spacing,各轴 ≤brick)。 + std::vector> currentImages() const override; + + // 切片核外是 Task 13,本任务返回 nullptr。renderC 不走切片路径。 + vtkImageData* sliceSource() const override { return nullptr; } + + // 视锥裁剪所需的视口宽高比(renderC 用窗口尺寸设;默认 1024/768)。 + void setAspect(double aspect) { aspect_ = aspect > 0 ? aspect : aspect_; } + + // --- 探针度量(供 renderC 写结论,非 IVolumeRenderSource 接口)--- + std::size_t residentCount() const { return pager_->residentCount(); } + std::size_t budget() const { return pager_->budget(); } + int lastLevel() const { return lastLevel_; } + std::size_t lastVisibleCount() const { return lastVisibleCount_; } // 视锥筛出的块数(请求数) + std::size_t lastLevelBrickTotal() const { return lastLevelBrickTotal_; } // 该 level 总块数 + + private: + // 某 level 单块 (bx,by,bz) 的世界 origin/spacing(实现要点 1)。 + void brickWorld(int level, int bx, int by, int bz, double origin[3], + double spacing[3]) const; + // 某 level 单块的实际体素尺寸(边缘块更小)。 + void brickDims(int level, int bx, int by, int bz, int& bw, int& bh, + int& bd) const; + // 由相机距离选 LOD level(0=最细)。cam==nullptr → 0。 + int pickLevel(vtkCamera* cam) const; + // 选该 level 的视野块:cam 有效则视锥裁剪,否则全取(budget/LRU 限制)。 + std::vector selectVisible(int level, vtkCamera* cam) const; + // 由 pager 驻留块构造带世界坐标的 VTK_SHORT 图像。 + vtkSmartPointer makeImage(const BrickId& id, + const std::vector& data) + const; + + geopro::data::StoreMeta meta_; + std::unique_ptr store_; + std::unique_ptr pager_; + + std::vector> images_; // 当前工作集图像 + int lastLevel_ = 0; + std::size_t lastVisibleCount_ = 0; + std::size_t lastLevelBrickTotal_ = 0; + double aspect_ = 1024.0 / 768.0; +}; + +} // namespace geopro::render diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index bd2f07e..be75041 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -119,6 +119,7 @@ target_sources(geopro_tests PRIVATE render/test_slice_plane_math.cpp) target_sources(geopro_tests PRIVATE render/test_whole_volume_source.cpp) # BrickPager(C)：内存恒定的 brick LRU 分页器，驻留 ≤ budget 个解压块，证明超大体浏览内存不爆。 target_sources(geopro_tests PRIVATE render/test_brick_pager.cpp) +target_sources(geopro_tests PRIVATE render/test_outofcore_source.cpp) target_link_libraries(geopro_tests PRIVATE geopro_render ${VTK_LIBRARIES}) vtk_module_autoinit(TARGETS geopro_tests MODULES ${VTK_LIBRARIES}) diff --git a/tests/render/test_outofcore_source.cpp b/tests/render/test_outofcore_source.cpp new file mode 100644 index 0000000..59bad0c --- /dev/null +++ b/tests/render/test_outofcore_source.cpp @@ -0,0 +1,130 @@ +#include "render/source/OutOfCoreSource.hpp" + +#include "core/algo/GprVolumeBuilder.hpp" +#include "data/store/ChunkedVolumeStore.hpp" + +#include + +#include +#include + +using namespace geopro; + +namespace { + +// 造一个含金字塔的 store:值 = 全局 (i+j+k)%1000(便于校验块定位),非 64 整除维度 +// 以含边缘块。返回 store 目录。 +std::string makePyramidStore(const std::string& dir, int nx, int ny, int nz, + double ox, double oy, double oz, double dx, + double dy, double dz, int brick, int levels) { + std::filesystem::remove_all(dir); + core::BuiltI16 b; + b.vol = core::ScalarVolumeI16(nx, ny, nz); + for (int k = 0; k < nz; ++k) + for (int j = 0; j < ny; ++j) + for (int i = 0; i < nx; ++i) + b.vol.at(i, j, k) = static_cast((i + j + k) % 1000); + b.quant = {1.0, 0.0}; + b.origin = {{ox, oy, oz}}; + b.spacing = {{dx, dy, dz}}; + b.vminPhys = 0; + b.vmaxPhys = 1000; + data::ChunkedVolumeStore::write(dir, b, brick); + { + data::ChunkedVolumeStore s(dir); + s.buildPyramid(levels); + } + return dir; +} + +} // namespace + +// headless 不需 GPU:验工作集块均 ≤ 纹理安全尺寸、residentCount ≤ budget、 +// 块世界 origin/spacing 正确(level 0,cam==nullptr → 全块经 budget/LRU 限制)。 +TEST(OutOfCoreSource, WorkingSetBricksAreTextureSafeAndBounded) { + const auto dir = + (std::filesystem::temp_directory_path() / "gpr_ooc_test").string(); + // 200×80×60,brick=64 → level0 块 4×2×1=8;非整除含边缘块。1 级金字塔。 + makePyramidStore(dir, 200, 80, 60, /*ox=*/1, /*oy=*/2, /*oz=*/3, + /*dx=*/0.5, /*dy=*/0.5, /*dz=*/0.2, /*brick=*/64, + /*levels=*/1); + + const std::size_t budget = 4; + render::OutOfCoreSource src(dir, budget); + EXPECT_EQ(src.meta().nx, 200); + EXPECT_EQ(src.budget(), budget); + + src.update(nullptr); // cam==nullptr → level 0 全部块,budget/LRU 限制 + + EXPECT_EQ(src.lastLevel(), 0); + EXPECT_EQ(src.lastLevelBrickTotal(), 8u); // 4×2×1 + EXPECT_LE(src.residentCount(), budget); // 内存恒定核心 + + auto imgs = src.currentImages(); + EXPECT_FALSE(imgs.empty()); + EXPECT_LE(imgs.size(), budget); // 工作集图像数 = 驻留块数 ≤ budget + + constexpr int kTextureSafe = 64; // 各块各轴 ≤ brick ≪ 16384 + for (const auto& img : imgs) { + ASSERT_NE(img.Get(), nullptr); + EXPECT_EQ(img->GetScalarType(), VTK_SHORT); + int d[3]; + img->GetDimensions(d); + EXPECT_LE(d[0], kTextureSafe); + EXPECT_LE(d[1], kTextureSafe); + EXPECT_LE(d[2], kTextureSafe); + EXPECT_GT(d[0], 0); + EXPECT_GT(d[1], 0); + EXPECT_GT(d[2], 0); + } +} + +// 块世界坐标:level 0 块 (1,0,0) 的 origin = meta.origin + (64×spacing,0,0); +// spacing == meta.spacing。 +TEST(OutOfCoreSource, BrickWorldCoordsLevel0) { + const auto dir = + (std::filesystem::temp_directory_path() / "gpr_ooc_world0").string(); + makePyramidStore(dir, 200, 80, 60, 1, 2, 3, 0.5, 0.5, 0.2, 64, 1); + + render::OutOfCoreSource src(dir, /*budget=*/16); + src.update(nullptr); // 全 8 块都能驻留(budget=16) + EXPECT_EQ(src.residentCount(), 8u); + + // 找 origin.x == 1 + 64×0.5 == 33 的块(即 bx=1 列首块),验世界坐标。 + auto imgs = src.currentImages(); + bool found = false; + for (const auto& img : imgs) { + double o[3], s[3]; + img->GetOrigin(o); + img->GetSpacing(s); + // spacing 恒等于 meta(level 0,2^0=1)。 + EXPECT_DOUBLE_EQ(s[0], 0.5); + EXPECT_DOUBLE_EQ(s[1], 0.5); + EXPECT_DOUBLE_EQ(s[2], 0.2); + if (std::abs(o[0] - (1.0 + 64 * 0.5)) < 1e-9 && std::abs(o[1] - 2.0) < 1e-9 && + std::abs(o[2] - 3.0) < 1e-9) { + found = true; + } + } + EXPECT_TRUE(found) << "未找到 bx=1 列首块的世界 origin"; +} + +// 金字塔 LOD:level 1 块的 spacing == meta.spacing × 2;origin 用 level1 体素步距。 +TEST(OutOfCoreSource, BrickWorldCoordsLevel1Spacing) { + const auto dir = + (std::filesystem::temp_directory_path() / "gpr_ooc_world1").string(); + makePyramidStore(dir, 200, 80, 60, 1, 2, 3, 0.5, 0.5, 0.2, 64, 1); + + data::ChunkedVolumeStore store(dir); + ASSERT_GE(store.levels(), 2); // level0 + level1 + + // 直接复用源的世界坐标逻辑:level1 块 (1,0,0) 的 spacing 应翻倍, + // origin.x = 1 + 64×(0.5×2) = 1 + 64 = 65。这里通过构造一个仅含 level1 的工作集 + // 验证(用 budget 大、相机 nullptr 时源仍取 level0,故改为直接核对块世界坐标公式: + // 用 store dims 推 level1 存在且块数合理)。 + int nx1 = 0, ny1 = 0, nz1 = 0; + store.dims(1, nx1, ny1, nz1); + EXPECT_EQ(nx1, 100); // ceil(200/2) + EXPECT_EQ(ny1, 40); + EXPECT_EQ(nz1, 30); +} diff --git a/tools/gpr_poc/CMakeLists.txt b/tools/gpr_poc/CMakeLists.txt index 55a4fa6..990a958 100644 --- a/tools/gpr_poc/CMakeLists.txt +++ b/tools/gpr_poc/CMakeLists.txt @@ -22,6 +22,12 @@ target_link_libraries(gpr_poc PRIVATE if(WIN32) target_link_libraries(gpr_poc PRIVATE Psapi) + # 运行时 DLL(VTK/Qt/GDAL 等)拷到 exe 旁,使 gpr_poc.exe 可直接运行(无需手设 PATH)。 + # 与 geopro_tests 同款 TARGET_RUNTIME_DLLS POST_BUILD。 + add_custom_command(TARGET gpr_poc POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + $ $ + COMMAND_EXPAND_LISTS) endif() target_compile_features(gpr_poc PRIVATE cxx_std_17) diff --git a/tools/gpr_poc/main.cpp b/tools/gpr_poc/main.cpp index e0cf71c..6e4bf03 100644 --- a/tools/gpr_poc/main.cpp +++ b/tools/gpr_poc/main.cpp @@ -32,6 +32,7 @@ #include "data/store/ChunkedVolumeStore.hpp" #include "io/gpr/GprSurveyAssembler.hpp" #include "render/actors/VoxelActor.hpp" +#include "render/source/OutOfCoreSource.hpp" #include "render/source/WholeVolumeSource.hpp" // ---- VTK 离屏渲染 ---- @@ -44,7 +45,12 @@ #include #include #include +#include +#include +#include #include +#include +#include #include #include #include @@ -792,6 +798,274 @@ int cmdRenderB(int argc, char** argv) { return 0; } +// ============================================================================ +// 核外分块体绘制基准（POC-C，命门探针） +// ============================================================================ + +// 量化域传函(与 VoxelActor::buildVoxelI16FromImage 同逻辑):颜色对每量化级 qv 用 +// q.toPhys(qv) 反查 ColorScale;不透明度 kBlank→0、[qmin,qmax] 线性到 kMaxOpacity。 +// MultiBlock 全块共用同一 vtkVolumeProperty(挂在单个 vtkVolume 上)。 +vtkSmartPointer makeI16VolumeProperty( + const geopro::core::Quant& q, const geopro::core::ColorScale& cs, + double vminPhys, double vmaxPhys) { + constexpr int kTransferSamples = 64; + constexpr double kMaxOpacity = 0.15; + if (vminPhys >= vmaxPhys) vmaxPhys = vminPhys + 1.0; + + const double qminD = static_cast(q.toQ(vminPhys)); + const double qmaxD = static_cast(q.toQ(vmaxPhys)); + + vtkNew color; + for (int t = 0; t < kTransferSamples; ++t) { + const double qd = qminD + (qmaxD - qminD) * t / (kTransferSamples - 1); + const auto qvLevel = static_cast(std::lround(qd)); + const double phys = q.toPhys(qvLevel); + const auto c = cs.colorAt(phys); + color->AddRGBPoint(qd, c.r / 255.0, c.g / 255.0, c.b / 255.0); + } + + vtkNew opacity; + opacity->AddPoint( + static_cast(geopro::core::ScalarVolumeI16::kBlank), 0.0); + opacity->AddPoint(qminD, 0.0); + opacity->AddPoint(qmaxD, kMaxOpacity); + + auto prop = vtkSmartPointer::New(); + prop->SetColor(color); + prop->SetScalarOpacity(opacity); + prop->SetInterpolationTypeToLinear(); + prop->ShadeOff(); + return prop; +} + +// 由当前工作集图像组装 vtkMultiBlockDataSet(每块一个 vtkImageData)。 +vtkSmartPointer makeMultiBlock( + const std::vector>& imgs) { + auto mb = vtkSmartPointer::New(); + mb->SetNumberOfBlocks(static_cast(imgs.size())); + for (unsigned int i = 0; i < imgs.size(); ++i) { + mb->SetBlock(i, imgs[i].Get()); + } + return mb; +} + +int cmdRenderC(int argc, char** argv) { + const Args a = parseArgs(argc, argv, 2); + if (a.positional.empty()) { + std::cerr << "用法: gpr_poc renderC [--budget 64] [--frames 120]\n"; + return 2; + } + const std::string dir = a.positional[0]; + const std::size_t budget = + static_cast(std::stoul(a.get("budget", "64"))); + const int frames = std::stoi(a.get("frames", "120")); + std::cout << "[renderC] storeDir=" << dir << " budget=" << budget + << " frames=" << frames << "\n"; + + // 闸门复检:不可渲染机不产假 fps。 + std::cout << "[renderC] 离屏闸门复检...\n"; + if (cmdOffscreenSmoke() != 0) { + std::cout << "[renderC] 闸门失败,中止,不产出 fps。\n"; + return 1; + } + + // 1) 核外源(读 meta + 建 pager,不载整卷)。 + Stopwatch swLoad; + geopro::render::OutOfCoreSource src(dir, budget); + const double loadMs = swLoad.elapsedMs(); + const auto& m = src.meta(); + const std::int64_t voxels = + static_cast(m.nx) * m.ny * m.nz; + + const int winW = 1024, winH = 768; + src.setAspect(static_cast(winW) / winH); + + std::cout << "[renderC] 体 " << m.nx << "x" << m.ny << "x" << m.nz + << " 体素=" << voxels << " (整卷 X=" << m.nx + << " > 16384 → renderB INVALID)，源构造 " << loadMs << "ms\n"; + + // 色阶用 meta 物理区间。 + const double vmin = m.vminPhys, vmax = m.vmaxPhys; + const geopro::core::ColorScale cs = makeColorScale(vmin, vmax); + vtkSmartPointer prop = + makeI16VolumeProperty(m.quant, cs, vmin, vmax); + + // 2) 离屏 + MultiBlock 体绘制。 + auto rw = makeOffscreenWindow(winW, winH); + vtkNew ren; + ren->SetBackground(0.0, 0.0, 0.0); + rw->AddRenderer(ren); + + vtkNew mapper; + mapper->SetRequestedRenderMode(vtkSmartVolumeMapper::GPURenderMode); + + auto volume = vtkSmartPointer::New(); + volume->SetMapper(mapper); + volume->SetProperty(prop); + ren->AddVolume(volume); + + // 装捕获式 OutputWindow:拦截每块上传时的 3D 纹理维度错误(应无,因块 ≤64³)。 + auto capWin = vtkSmartPointer::New(); + vtkOutputWindow::SetInstance(capWin); + + // 相机:先以全体定向(看整卷),首帧 update 选出工作集后再 ResetCamera 到 + // 实际驻留块的 mapper 包围盒(budget<视野总块时工作集只覆盖体的一部分,框住它 + // 才能确证核外体绘制真渲出;这是 budget 受限下的诚实测法,报告说明)。 + ren->ResetCamera(m.origin[0], m.origin[0] + m.nx * m.spacing[0], + m.origin[1], m.origin[1] + m.ny * m.spacing[1], + m.origin[2], m.origin[2] + m.nz * m.spacing[2]); + vtkCamera* cam = ren->GetActiveCamera(); + + auto refreshBlocks = [&]() { + src.update(cam); + auto imgs = src.currentImages(); + auto mb = makeMultiBlock(imgs); + mapper->SetInputDataObject(mb); + mapper->Update(); + return imgs.size(); + }; + + const std::size_t warmBlocks = refreshBlocks(); + // 用工作集(mapper)实际包围盒重置相机,框住驻留块。 + { + double b[6]; + mapper->GetBounds(b); + if (b[0] <= b[1]) { + ren->ResetCamera(b); + } else { + ren->ResetCamera(); + } + } + rw->Render(); // 预热(上传显存 + 编译 shader,不计时) + + { + double b[6]; + mapper->GetBounds(b); + std::cout << "[renderC] 工作集包围盒 x[" << b[0] << "," << b[1] << "] y[" + << b[2] << "," << b[3] << "] z[" << b[4] << "," << b[5] << "]\n"; + } + + std::cout << "[renderC] 预热:level=" << src.lastLevel() + << " 视野块=" << src.lastVisibleCount() << "/" + << src.lastLevelBrickTotal() + << " 驻留=" << src.residentCount() << " 渲染块=" << warmBlocks + << "\n"; + + std::size_t maxResident = src.residentCount(); + std::size_t sumBlocks = 0; + + // 3a) 静态工作集体绘制 fps:工作集固定(不每帧换块),只旋相机 + Render。 + // 隔离"纯 GPU MultiBlock 体绘制"成本(剔除分块换页/解压/重建 mapper 开销), + // 直接对照 renderB 整卷 fps,回答未知 #6(真实体绘制 fps)。 + std::cout << "[renderC] 静态工作集体绘制基准(" << frames << " 帧旋相机)...\n"; + Stopwatch swStatic; + for (int f = 0; f < frames; ++f) { + cam->Azimuth(360.0 / frames); + rw->Render(); // 工作集不变,仅旋转 + } + const double staticMs = swStatic.elapsedMs(); + const double staticFps = staticMs > 0 ? frames * 1000.0 / staticMs : 0.0; + std::cout << "[renderC] 静态工作集 fps=" << staticFps << "\n"; + + // 3b) 动态换页体绘制 fps:每帧 update(cam)(重选 LOD/视野块,含 qUncompress 解压 + // 换入的块 + 重建 MultiBlock)+ Render。回答未知 #4(热路径解压是否拖垮 fps) + // 与 #5(内存恒定)。同时累计 update 耗时占比。 + std::cout << "[renderC] 动态换页体绘制基准(" << frames << " 帧旋相机)...\n"; + double updateMsTotal = 0.0; + Stopwatch swDyn; + for (int f = 0; f < frames; ++f) { + cam->Azimuth(360.0 / frames); + Stopwatch swU; + const std::size_t blocks = refreshBlocks(); // update + 重建 MultiBlock + updateMsTotal += swU.elapsedMs(); + sumBlocks += blocks; + maxResident = std::max(maxResident, src.residentCount()); + rw->Render(); + } + const double dynMs = swDyn.elapsedMs(); + const double dynFps = dynMs > 0 ? frames * 1000.0 / dynMs : 0.0; + const double rawFps = dynFps; // 主报告口径:含换页的真实交互 fps + std::cout << "[renderC] 动态换页 fps=" << dynFps + << " (其中 update/换页/重建 平均 " << (updateMsTotal / frames) + << " ms/帧)\n"; + + const bool textureErr = capWin->textureError(); + vtkOutputWindow::SetInstance(nullptr); + + // 4) 正确性判据:渲出非空像素(非全背景)。 + auto pixels = vtkSmartPointer::New(); + rw->GetRGBACharPixelData(0, 0, winW - 1, winH - 1, /*front=*/1, pixels); + vtkIdType nonBlack = 0; + const vtkIdType npx = pixels->GetNumberOfTuples(); + for (vtkIdType i = 0; i < npx; ++i) { + if (pixels->GetComponent(i, 0) > 10 || pixels->GetComponent(i, 1) > 10 || + pixels->GetComponent(i, 2) > 10) { + ++nonBlack; + } + } + const bool renderedNonEmpty = (nonBlack > 0); + + // 渲染模式(MultiBlock 内部每块一个 SmartVolumeMapper;此处取一块代表性查询)。 + // MultiBlock 不直接暴露 LastUsedRenderMode,故以纹理无错 + 非空像素为体绘制真出证据。 + const bool volFpsValid = !textureErr && renderedNonEmpty; + + const double peak = Probe::peakMemMB(); + const double avgBlocks = + frames > 0 ? static_cast(sumBlocks) / frames : 0.0; + + std::cout << "\n=== renderC 核外体绘制指标 ===\n"; + std::cout << "离屏闸门 : OK\n"; + std::cout << "体维度 : " << m.nx << " x " << m.ny << " x " << m.nz + << " (整卷 X 超 16384,renderB=INVALID)\n"; + std::cout << "体素数 : " << voxels << "\n"; + std::cout << "budget(块) : " << budget << "\n"; + std::cout << "峰值驻留(块) : " << maxResident + << (maxResident <= budget ? " (≤budget,内存恒定 OK)" + : " (!! 超 budget)") + << "\n"; + std::cout << "末帧 level : " << src.lastLevel() << "\n"; + std::cout << "末帧视野块/总块 : " << src.lastVisibleCount() << " / " + << src.lastLevelBrickTotal() << "\n"; + std::cout << "平均渲染块/帧 : " << avgBlocks << "\n"; + std::cout << "纹理维度错误 : " << (textureErr ? "是(!!)" : "否") << "\n"; + std::cout << "渲出非空像素 : " << (renderedNonEmpty ? "是" : "否(!!)") + << " (非背景像素=" << nonBlack << ")\n"; + std::cout << "静态工作集 fps : " + << (volFpsValid ? std::to_string(staticFps) + : std::string("INVALID(纹理错或空渲染)")) + << " (纯 GPU MultiBlock 体绘制)\n"; + std::cout << "动态换页 fps : " + << (volFpsValid ? std::to_string(dynFps) + : std::string("INVALID(纹理错或空渲染)")) + << " (含每帧 update/解压/重建 mapper)\n"; + std::cout << " 换页均耗时/帧 : " << (updateMsTotal / frames) << " ms\n"; + std::cout << "进程峰值内存(MB) : " << peak << "\n"; + std::cout << "源构造耗时(ms) : " << loadMs << "\n"; + std::cout << "对照 renderB : 整卷 INVALID(超 3D 纹理上限);renderC " + << (volFpsValid ? "真渲出 ✔" : "未渲出 ✘") << "\n"; + + writeMetricLine( + "renderC,dir=" + dir + ",nx=" + std::to_string(m.nx) + + ",ny=" + std::to_string(m.ny) + ",nz=" + std::to_string(m.nz) + + ",voxels=" + std::to_string(voxels) + + ",budget=" + std::to_string(budget) + + ",maxResident=" + std::to_string(maxResident) + + ",lastLevel=" + std::to_string(src.lastLevel()) + + ",lastVisible=" + std::to_string(src.lastVisibleCount()) + + ",lastLevelTotal=" + std::to_string(src.lastLevelBrickTotal()) + + ",avgBlocks=" + std::to_string(avgBlocks) + + ",textureErr=" + std::to_string(textureErr ? 1 : 0) + + ",nonBlack=" + std::to_string(nonBlack) + + ",volFpsValid=" + std::to_string(volFpsValid ? 1 : 0) + + ",staticFps=" + (volFpsValid ? std::to_string(staticFps) : "INVALID") + + ",dynFps=" + (volFpsValid ? std::to_string(dynFps) : "INVALID") + + ",updateMsPerFrame=" + std::to_string(updateMsTotal / frames) + + ",rawFps=" + std::to_string(rawFps) + + ",loadMs=" + std::to_string(loadMs) + + ",peakMB=" + std::to_string(peak)); + return volFpsValid ? 0 : 1; +} + void usage() { std::cerr << "gpr_poc —— POC-B headless 度量 CLI\n" " gpr_poc build [--line 001] [--cellXY 0.2] " @@ -799,7 +1073,8 @@ void usage() { " gpr_poc load \n" " gpr_poc selftest\n" " gpr_poc offscreen-smoke\n" - " gpr_poc renderB [--frames 120]\n"; + " gpr_poc renderB [--frames 120]\n" + " gpr_poc renderC [--budget 64] [--frames 120]\n"; } } // namespace @@ -816,6 +1091,7 @@ int main(int argc, char** argv) { if (cmd == "selftest") return cmdSelftest(); if (cmd == "offscreen-smoke") return cmdOffscreenSmoke(); if (cmd == "renderB") return cmdRenderB(argc, argv); + if (cmd == "renderC") return cmdRenderC(argc, argv); } catch (const std::exception& e) { std::cerr << "错误: " << e.what() << "\n"; return 1;