From a0aae48ec8cb8a379909b88df1aeef45663f2985 Mon Sep 17 00:00:00 2001 From: OpenAI Codex Date: Thu, 3 Sep 2026 15:04:05 +0800 Subject: [PATCH] feat: draw all raster particle states --- ...TEP-044_Android_OpenGL粒子数量容量基线_v2.md | 37 +++++ ...d_OpenGL粒子数量容量基线_Codex完成报告_v2.md | 42 +++++ .../shaders/gl/particle_gpu_validation.hpp | 27 +++- shaders/particle_gpu_validation.fragment.glsl | 16 +- shaders/particle_gpu_validation.vertex.glsl | 11 ++ .../render_particle_validation_layer.cpp | 144 +++++++++++++++++- 粒子开发记录.md | 8 + 7 files changed, 277 insertions(+), 8 deletions(-) create mode 100644 docs/50_Step记录/STEP-044_Android_OpenGL粒子数量容量基线_v2.md create mode 100644 docs/报告/40-03_Android_OpenGL粒子数量容量基线_Codex完成报告_v2.md diff --git a/docs/50_Step记录/STEP-044_Android_OpenGL粒子数量容量基线_v2.md b/docs/50_Step记录/STEP-044_Android_OpenGL粒子数量容量基线_v2.md new file mode 100644 index 000000000..8b00f7a9c --- /dev/null +++ b/docs/50_Step记录/STEP-044_Android_OpenGL粒子数量容量基线_v2.md @@ -0,0 +1,37 @@ +# STEP-044 Android OpenGL 粒子数量容量基线 v2 + +- 状态：`IMPLEMENTED / WAITING FOR ANDROID VALIDATION` +- 基线：`c0d1ad43c49ed6d526c3fd8b982c04840326d0d0` 的容量档位实现。 +- 范围：补齐正式 RasterParticle 的 full particle draw；不是新 Step，也不是容量结论或性能优化。 + +## v1 的实际缺口 + +v1 已让 State A/B 容量随 `raster-particle-particle-count` 改为 256 至 1,048,576，但 Trail fragment 只读取四个固定 State UV。因此当时只能证明 N 个 State 同时 simulation，不能证明 N 个粒子同时 Trail/render/composite；Android 容量验收据此暂停。 + +## v2 补齐 + +- `effectiveParticleCount=N -> State N -> Trail draw N -> Composite` 已进入唯一正式 `RasterArraySource -> RasterParticleLayer -> RenderRasterParticleLayer` 链。 +- 每个粒子在 State A/B 中对应一条静态 GPU vertex：`particleIndex -> x=index%stateGridWidth, y=index/stateGridWidth`。vertex buffer 仅在 resource create 或 particle-count change 重建；顶点 shader 用 `(x+0.5,y+0.5)/stateGrid` 采样当前 State write texture，位置从未 CPU 生成或 readback。 +- Trail write target 先由全屏 Trail fade quad 消费前一 Trail，再追加 full point draw。每粒子一个 point，`trailDrawCount=N`；Composite 继续消费同一 Trail A/B write target。 +- 现有 16-bit index 路径每 segment 最多 65,536 points；更高 count（包括 1M）被分为多个 segment，仍使用同一 static index buffer、同一 shader 和同一 State texture，非第二 simulation。 +- legacy `ParticleValidationLayer` 仍保留四个 deterministic sample 诊断；正式 RasterParticle Layer 的路径不再使用它们作为 draw 数量限制。 + +## 生命周期与冻结语义 + +- particle-count change 继续只触发合理的 State A/B 和 full-draw resource rebuild，以及 `SIMULATION_RESET reason=PARTICLE_COUNT_CHANGE` / reseed。 +- Field T0/T1、MIX、interpolation、Field reuse、mask、A/B→B/C 及既有 State/Trail ping-pong 没有改变。MIX 仍不能导致 draw resource rebuild、Style reload、Field upload 或 reset。 +- State seed 仍是每个 State texel 的 `v_uv`，所以 full draw 的首次 256/1K 粒子已经 deterministic 地分布在完整 grid，而非重叠于一个点。 + +## 观测日志 + +资源 create/rebuild/release 日志含 `effectiveParticleCount`、`stateGrid`、`trailDrawCount`、`particleIndexCount`、`fullParticleDraw=true` 和 `resourceGeneration`。`PARTICLE_DRAW_REJECTED` 明确报告缺失 draw resource 或 drawable finalize failure。 + +## 待 Android 验收 + +| 用例 | 要求 | 状态 | +|---|---|---| +| T-FULL-01 | 256：`16x16`、`trailDrawCount=256`、明显粒子群并持续运动 | 待测 | +| T-FULL-02 | 1K：`32x32`、`trailDrawCount=1024`、密度明显大于 256、Trail/Composite 正常 | 待测 | +| T-FULL-03 | 256→1K→256：draw count 同步变化，无 crash、Style reload、Field upload 或 MIX 改变 | 待测 | + +只有 T-FULL-01～03 通过，才恢复 4K / 16K / 64K / 1M 的容量矩阵。Codex 未运行 Android Gradle、ADB、安装或设备测试；未加入 Jest。 diff --git a/docs/报告/40-03_Android_OpenGL粒子数量容量基线_Codex完成报告_v2.md b/docs/报告/40-03_Android_OpenGL粒子数量容量基线_Codex完成报告_v2.md new file mode 100644 index 000000000..d2ff004ed --- /dev/null +++ b/docs/报告/40-03_Android_OpenGL粒子数量容量基线_Codex完成报告_v2.md @@ -0,0 +1,42 @@ +# 40-03 Android OpenGL 粒子数量容量基线 Codex 完成报告 v2 + +## 状态 + +`40-03：IMPLEMENTED / WAITING FOR ANDROID VALIDATION` + +v1 的 Android 容量验证暂停是正确的：它的 State A/B 已支持 N 个状态，但 Trail/render 只消费四个固定 State sample。本次补齐后尚无 Android 实机证据，不能写 `CLOSED / PASS`。 + +## 已完成 + +1. 原固定 sample 位于 `shaders/particle_gpu_validation.fragment.glsl` 的 Trail 分支，固定 State UV 为 0.125、0.375、0.625、0.875；原 Trail 实际是一个全屏 quad，6 个 index，并非 N 个粒子 draw。 +2. 正式 full draw 采用静态 State-index vertex buffer，而不是 GPU instance ID：每个 index 一次性映射到 `(x=index%width, y=index/width)`，数目等于 `effectiveParticleCount`。它在初始资源创建和 count rebuild 创建/释放，稳定帧不做 CPU 粒子循环。 +3. formal Trail pass 先用既有全屏 quad 衰减 previous Trail，随后以 `gfx::Points` 提交所有 static State index。vertex shader 从当前 State write texture 读取该 index 的 RG position；每个 point 进入同一 Trail A/B target，Composite 无改动地读取 Trail write。 +4. 256 时 `trailDrawCount=256`；1K 时 `trailDrawCount=1024`。1M 使用相同机制，按最多 65,536 points 的 16-bit-index segment 切分为多个 draw segment，理论路径为 1,048,576 State texel / point draw。 +5. 固定四 sample 仅保留给 legacy `ParticleValidationLayer` 诊断。正式 RasterParticle Layer 不再依赖它们；没有 GPU→CPU readback、每帧 CPU position 生成、旁路 overlay 或第二 simulation。 +6. State seed 保持每个 State texel 的 `v_uv`，无需改变 reseed；每粒子初始位置已是 deterministic grid-distributed。没有修改 U/V、`dy=-v`、Field sampling、T0/T1、MIX、JNI 或 40-02 resource identity 语义。 +7. `PARTICLE_DRAW_RESOURCES_CREATE|REBUILD|RELEASE` 与 `PARTICLE_DRAW_REJECTED` 日志新增/补齐 `effectiveParticleCount`、`stateGrid`、`trailDrawCount`、`particleIndexCount`、`fullParticleDraw=true` 和 generation。 + +## 本地检查 + +- shader generator 连续两次运行，生成物稳定；源 GLSL 是唯一修改入口。 +- Linux/OpenGL 精确编译通过：`render_particle_validation_layer.cpp.o`、`raster_particle_layer.cpp.o`、`style_layer.test.cpp.o`。 +- 相关 Layer test object 已编译；完整测试二进制当前 build tree 不存在，未误报运行通过。 +- `clang-format --dry-run --Werror`、`git diff --check`：通过。 +- 未运行 Android Gradle、ADB、APK、设备测试或 Jest；没有 APK packaging 改动。 + +## 待用户 Android 验证 + +先只执行 T-FULL-01～03：256、1K、256→1K→256。确认 `trailDrawCount` 等于 effective count、视觉密度变化、持续运动，以及没有 Style reload / Field upload / MIX 改变后，再扩展到 4K/16K/64K/1M。 + +PowerShell 或 CMD： + +```powershell +cd /mnt/sda1/MapLibreParticleLab/platform/android +./gradlew :MapLibreAndroidTestApp:assembleOpenglDebug -Pandroid.injected.build.abi=x86_64 --console=plain +adb -s 192.168.1.146 install -r .\MapLibreAndroidTestApp\build\intermediates\apk\opengl\debug\MapLibreAndroidTestApp-opengl-debug.apk +adb -s 192.168.1.146 logcat -c +adb -s 192.168.1.146 shell am start -n org.maplibre.android.testapp/.activity.particle.ParticleCoreLayerValidationActivity +adb -s 192.168.1.146 logcat -v time | Select-String -Pattern 'ParticleGPU|PARTICLE_COUNT|STATE|DRAW|trailDrawCount|effectiveParticleCount|stateGrid|fullParticleDraw|STYLE|FIELD|MIX' +``` + +APK：`./MapLibreAndroidTestApp/build/intermediates/apk/opengl/debug/MapLibreAndroidTestApp-opengl-debug.apk`。 diff --git a/include/mbgl/shaders/gl/particle_gpu_validation.hpp b/include/mbgl/shaders/gl/particle_gpu_validation.hpp index 6ae141412..5fde5acc2 100644 --- a/include/mbgl/shaders/gl/particle_gpu_validation.hpp +++ b/include/mbgl/shaders/gl/particle_gpu_validation.hpp @@ -20,11 +20,22 @@ layout (std140) uniform ParticleGpuValidationUBO { highp mat4 u_matrix; }; +uniform sampler2D u_state_texture; + void main() { v_uv = a_pos; v_world = a_pos; if (u_pass.x < 1.5) { gl_Position = vec4(a_pos * 2.0 - 1.0, 0.0, 1.0); + } else if (u_pass.x > 3.5) { + // 40-03: a_pos is a static State texel index generated only when the + // particle capacity changes. The position itself remains GPU-owned. + vec2 stateUV = (a_pos + vec2(0.5)) / u_mask.xy; + vec2 position = texture(u_state_texture, stateUV).rg; + v_uv = position; + v_world = position; + gl_PointSize = 3.0; + gl_Position = vec4(position * 2.0 - 1.0, 0.0, 1.0); } else { // VALIDATION ONLY: a_pos is canonical z0 world geometry; u_matrix is // PaintParameters::matrixForTile() for the selected MapLibre world copy. @@ -74,8 +85,15 @@ void main() { if (any(isnan(velocity))) position = v_uv; fragColor = vec4(position, fract(previous.b + 0.03125 * u_pass.y), 1.0); } else if (mode < 1.5) { - // The trail consumes State B/A written by the real field-sampling pass. - // Four deterministic texels are enough for the Stage A visual proof. + // Formal Trail first fades the previous target. Its full-particle point + // draw follows in the same target and consumes every State texel. + if (u_mask.z > 0.5) { + fragColor = vec4(previous.rgb * u_marker.w, 1.0); + return; + } + + // LEGACY VALIDATION DISPLAY: retain the original four deterministic + // samples for the historical ParticleValidationLayer only. float marker = 0.0; marker = max(marker, 1.0 - smoothstep(0.0, u_marker.z, distance(v_uv, texture(u_state_texture, vec2(0.125, 0.125)).rg))); marker = max(marker, 1.0 - smoothstep(0.0, u_marker.z, distance(v_uv, texture(u_state_texture, vec2(0.375, 0.375)).rg))); @@ -83,6 +101,11 @@ void main() { marker = max(marker, 1.0 - smoothstep(0.0, u_marker.z, distance(v_uv, texture(u_state_texture, vec2(0.875, 0.875)).rg))); vec3 color = previous.rgb * u_marker.w + marker * vec3(0.08, 0.55, 1.0); fragColor = vec4(min(color, vec3(1.0)), 1.0); + } else if (mode > 3.5) { + // The vertex shader fetched this particle's State texel directly from + // the current State write texture. Every point contributes one formal + // particle draw; no CPU position data is involved per frame. + fragColor = vec4(0.08, 0.55, 1.0, 1.0); } else { // The formal RasterParticle layer displays the Trail texture written by // the current State -> Trail pass. Legacy ParticleValidation keeps its diff --git a/shaders/particle_gpu_validation.fragment.glsl b/shaders/particle_gpu_validation.fragment.glsl index 79c7c6171..405e79685 100644 --- a/shaders/particle_gpu_validation.fragment.glsl +++ b/shaders/particle_gpu_validation.fragment.glsl @@ -40,8 +40,15 @@ void main() { if (any(isnan(velocity))) position = v_uv; fragColor = vec4(position, fract(previous.b + 0.03125 * u_pass.y), 1.0); } else if (mode < 1.5) { - // The trail consumes State B/A written by the real field-sampling pass. - // Four deterministic texels are enough for the Stage A visual proof. + // Formal Trail first fades the previous target. Its full-particle point + // draw follows in the same target and consumes every State texel. + if (u_mask.z > 0.5) { + fragColor = vec4(previous.rgb * u_marker.w, 1.0); + return; + } + + // LEGACY VALIDATION DISPLAY: retain the original four deterministic + // samples for the historical ParticleValidationLayer only. float marker = 0.0; marker = max(marker, 1.0 - smoothstep(0.0, u_marker.z, distance(v_uv, texture(u_state_texture, vec2(0.125, 0.125)).rg))); marker = max(marker, 1.0 - smoothstep(0.0, u_marker.z, distance(v_uv, texture(u_state_texture, vec2(0.375, 0.375)).rg))); @@ -49,6 +56,11 @@ void main() { marker = max(marker, 1.0 - smoothstep(0.0, u_marker.z, distance(v_uv, texture(u_state_texture, vec2(0.875, 0.875)).rg))); vec3 color = previous.rgb * u_marker.w + marker * vec3(0.08, 0.55, 1.0); fragColor = vec4(min(color, vec3(1.0)), 1.0); + } else if (mode > 3.5) { + // The vertex shader fetched this particle's State texel directly from + // the current State write texture. Every point contributes one formal + // particle draw; no CPU position data is involved per frame. + fragColor = vec4(0.08, 0.55, 1.0, 1.0); } else { // The formal RasterParticle layer displays the Trail texture written by // the current State -> Trail pass. Legacy ParticleValidation keeps its diff --git a/shaders/particle_gpu_validation.vertex.glsl b/shaders/particle_gpu_validation.vertex.glsl index a8f14623b..1ab2c5dc3 100644 --- a/shaders/particle_gpu_validation.vertex.glsl +++ b/shaders/particle_gpu_validation.vertex.glsl @@ -10,11 +10,22 @@ layout (std140) uniform ParticleGpuValidationUBO { highp mat4 u_matrix; }; +uniform sampler2D u_state_texture; + void main() { v_uv = a_pos; v_world = a_pos; if (u_pass.x < 1.5) { gl_Position = vec4(a_pos * 2.0 - 1.0, 0.0, 1.0); + } else if (u_pass.x > 3.5) { + // 40-03: a_pos is a static State texel index generated only when the + // particle capacity changes. The position itself remains GPU-owned. + vec2 stateUV = (a_pos + vec2(0.5)) / u_mask.xy; + vec2 position = texture(u_state_texture, stateUV).rg; + v_uv = position; + v_world = position; + gl_PointSize = 3.0; + gl_Position = vec4(position * 2.0 - 1.0, 0.0, 1.0); } else { // VALIDATION ONLY: a_pos is canonical z0 world geometry; u_matrix is // PaintParameters::matrixForTile() for the selected MapLibre world copy. diff --git a/src/mbgl/renderer/layers/render_particle_validation_layer.cpp b/src/mbgl/renderer/layers/render_particle_validation_layer.cpp index e1fc6647f..60f9eec7d 100644 --- a/src/mbgl/renderer/layers/render_particle_validation_layer.cpp +++ b/src/mbgl/renderer/layers/render_particle_validation_layer.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -34,6 +35,7 @@ #include #include #include +#include #include #include @@ -73,6 +75,7 @@ enum class ValidationPass : uint8_t { Trail = 1, Composite = 2, FrozenComposite = 3, + TrailParticles = 4, }; const char* slotName(const uint8_t slot) { @@ -206,7 +209,10 @@ public: std::shared_ptr nextFieldImage; std::shared_ptr maskFixture; std::shared_ptr> vertices; + std::shared_ptr> particleVertices; + gfx::IndexVectorBasePtr particleIndices; SegmentVector segments; + SegmentVector particleSegments; uint8_t stateWrite() const { return static_cast(1 - stateRead); } uint8_t trailWrite() const { return static_cast(1 - trailRead); } @@ -255,6 +261,33 @@ public: namespace { +constexpr uint32_t MaxParticleVerticesPerSegment = std::numeric_limits::max() + 1u; + +void rebuildParticleDrawResources(const std::shared_ptr& resources) { + auto vertices = std::make_shared>(); + vertices->reserve(resources->particleCount); + for (uint32_t particleIndex = 0; particleIndex < resources->particleCount; ++particleIndex) { + const auto x = static_cast(particleIndex % resources->stateSize.width); + const auto y = static_cast(particleIndex / resources->stateSize.width); + vertices->emplace_back(HeatmapBucket::textureVertex({x, y})); + } + + auto indices = std::make_shared(); + indices->reserve(std::min(resources->particleCount, MaxParticleVerticesPerSegment)); + for (uint32_t index = 0; index < std::min(resources->particleCount, MaxParticleVerticesPerSegment); ++index) { + indices->extend(1, static_cast(index)); + } + + SegmentVector segments; + for (uint32_t offset = 0; offset < resources->particleCount; offset += MaxParticleVerticesPerSegment) { + const auto count = std::min(resources->particleCount - offset, MaxParticleVerticesPerSegment); + segments.emplace_back(offset, 0, count, count); + } + resources->particleVertices = std::move(vertices); + resources->particleIndices = std::move(indices); + resources->particleSegments = std::move(segments); +} + class ParticleGpuValidationTweaker final : public gfx::DrawableTweaker { public: ParticleGpuValidationTweaker(std::shared_ptr state_, @@ -311,8 +344,8 @@ public: const shaders::ParticleGpuValidationUBO ubo = { .pass = {static_cast(pass), frame, maskMode == 0 ? 0.0f : 1.0f, static_cast(maskMode)}, .marker = {markerX, markerY, 0.035f, 0.965f}, - .mask = {static_cast(resources->maskGeneration), - static_cast(worldWrap), + .mask = {static_cast(resources->stateSize.width), + static_cast(resources->stateSize.height), resources->formalDisplay ? 1.0f : 0.0f, seedState ? 1.0f : 0.0f}, .matrix = util::cast(parameters.matrixForTile({worldWrap, {0, 0, 0}})), @@ -527,6 +560,63 @@ bool buildQuad(gfx::Context& context, return true; } +bool buildParticlePoints(gfx::Context& context, + const std::shared_ptr& resources, + LayerGroup& group, + const std::string& name, + const gfx::Texture2DPtr& stateTexture, + const gfx::Texture2DPtr& target, + const uint8_t stateSlot, + const uint8_t trailSlot) { + if (!resources->particleVertices || !resources->particleIndices || resources->particleSegments.empty() || + !stateTexture || !target) { + Log::Error(Event::Render, "ParticleGPU: event=PARTICLE_DRAW_REJECTED reason=MISSING_DRAW_RESOURCES"); + return false; + } + auto attributes = context.createVertexAttributeArray(); + if (const auto& attribute = attributes->set(shaders::idParticleGpuValidationPosVertexAttribute)) { + attribute->setSharedRawData(resources->particleVertices, + offsetof(HeatmapTextureLayoutVertex, a1), + 0, + sizeof(HeatmapTextureLayoutVertex), + gfx::AttributeDataType::Short2); + } + + auto builder = context.createDrawableBuilder(name); + builder->setShader(resources->shader); + builder->setRenderPass(RenderPass::Translucent); + builder->setEnableDepth(false); + builder->setColorMode(gfx::ColorMode::unblended()); + builder->setCullFaceMode(gfx::CullFaceMode::disabled()); + builder->setVertexAttributes(std::move(attributes)); + builder->setRawVertices({}, resources->particleVertices->elements(), gfx::AttributeDataType::Short2); + builder->setSegments(gfx::Points(3.0f), + resources->particleIndices, + resources->particleSegments.data(), + resources->particleSegments.size()); + builder->setTexture(stateTexture, shaders::idParticleGpuValidationPreviousTexture); + builder->setTexture(stateTexture, shaders::idParticleGpuValidationStateTexture); + builder->addTweaker(std::make_shared(resources, + ValidationPass::TrailParticles, + stateSlot, + trailSlot, + stateTexture, + target, + resources->maskTexture, + stateTexture, + 0.0f, + 0, + 0)); + builder->flush(context); + auto drawables = builder->clearDrawables(); + if (drawables.size() != 1 || !drawables.front()) { + Log::Error(Event::Render, "ParticleGPU: event=PARTICLE_DRAW_REJECTED reason=DRAWABLE_FINALIZE_FAILED"); + return false; + } + group.addDrawable(std::move(drawables.front())); + return true; +} + } // namespace RenderRasterParticleLayer::RenderRasterParticleLayer(Immutable impl_) @@ -596,6 +686,10 @@ void RenderRasterParticleLayer::layerRemoved(UniqueChangeRequestVec& changes) { "ParticleGPU: event=PARTICLE_RESOURCES_RELEASE reason=LAYER_REMOVED particleCount=" + std::to_string(gpuResources->particleCount) + " resourceGeneration=" + std::to_string(gpuResources->generation)); + Log::Info(Event::Render, + "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_RELEASE reason=LAYER_REMOVED trailDrawCount=" + + std::to_string(gpuResources->particleVertices ? gpuResources->particleVertices->elements() : 0) + + " fullParticleDraw=true resourceGeneration=" + std::to_string(gpuResources->generation)); removeTargets(gpuResources->registeredTargets, changes); gpuResources->registeredTargets.clear(); } @@ -609,6 +703,10 @@ void RenderRasterParticleLayer::markContextDestroyed() { "ParticleGPU: event=PARTICLE_RESOURCES_RELEASE reason=CONTEXT_DESTROYED particleCount=" + std::to_string(gpuResources->particleCount) + " resourceGeneration=" + std::to_string(gpuResources->generation)); + Log::Info(Event::Render, + "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_RELEASE reason=CONTEXT_DESTROYED trailDrawCount=" + + std::to_string(gpuResources->particleVertices ? gpuResources->particleVertices->elements() : 0) + + " fullParticleDraw=true resourceGeneration=" + std::to_string(gpuResources->generation)); Log::Info( Event::Render, "ParticleValidation30_02: context lost discard generation=" + std::to_string(gpuResources->generation) + @@ -665,6 +763,7 @@ void RenderRasterParticleLayer::update(gfx::ShaderRegistry& shaders, owned->segments = RenderStaticData::heatmapTextureSegments(); owned->particleCount = particleCount; owned->stateSize = particleStateSize(owned->particleCount); + rebuildParticleDrawResources(owned); for (uint8_t i = 0; i < 2; ++i) { owned->stateTargets[i] = createValidationTarget( context, owned->stateSize, getID() + "-state-" + slotName(i), gfx::TextureFilterType::Nearest); @@ -749,6 +848,13 @@ void RenderRasterParticleLayer::update(gfx::ShaderRegistry& shaders, " effectiveParticleCount=" + std::to_string(resources->particleCount) + " stateGrid=" + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + " resourceGeneration=" + std::to_string(resources->generation)); + Log::Info(Event::Render, + "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_CREATE effectiveParticleCount=" + + std::to_string(resources->particleCount) + " stateGrid=" + + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + + " trailDrawCount=" + std::to_string(resources->particleVertices->elements()) + + " particleIndexCount=" + std::to_string(resources->particleVertices->elements()) + + " fullParticleDraw=true resourceGeneration=" + std::to_string(resources->generation)); Log::Info( Event::Render, "ParticleField: fixture loaded id=" + resources->field.fixtureID + " type=" + resources->field.fieldType + @@ -806,10 +912,15 @@ void RenderRasterParticleLayer::update(gfx::ShaderRegistry& shaders, std::to_string(previousCount) + " stateGrid=" + std::to_string(previousSize.width) + "x" + std::to_string(previousSize.height) + " resourceGeneration=" + std::to_string(resources->generation)); + Log::Info(Event::Render, + "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_RELEASE reason=PARTICLE_COUNT_CHANGE trailDrawCount=" + + std::to_string(resources->particleVertices ? resources->particleVertices->elements() : 0) + + " fullParticleDraw=true resourceGeneration=" + std::to_string(resources->generation)); removeTargets(resources->stateTargets, changes); resources->stateTargets = std::move(replacementTargets); resources->particleCount = particleCount; resources->stateSize = requestedSize; + rebuildParticleDrawResources(resources); resources->resetSequence("PARTICLE_COUNT_CHANGE"); Log::Info(Event::Render, "ParticleGPU: event=PARTICLE_RESOURCES_REBUILD reason=PARTICLE_COUNT_CHANGE requestedParticleCount=" + @@ -817,6 +928,13 @@ void RenderRasterParticleLayer::update(gfx::ShaderRegistry& shaders, " effectiveParticleCount=" + std::to_string(resources->particleCount) + " stateGrid=" + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + " resourceGeneration=" + std::to_string(resources->generation)); + Log::Info(Event::Render, + "ParticleGPU: event=PARTICLE_DRAW_RESOURCES_REBUILD effectiveParticleCount=" + + std::to_string(resources->particleCount) + " stateGrid=" + + std::to_string(resources->stateSize.width) + "x" + std::to_string(resources->stateSize.height) + + " trailDrawCount=" + std::to_string(resources->particleVertices->elements()) + + " particleIndexCount=" + std::to_string(resources->particleVertices->elements()) + + " fullParticleDraw=true resourceGeneration=" + std::to_string(resources->generation)); } const bool sourceChanged = formalSource && sourceField && sourceNextField && @@ -1028,6 +1146,15 @@ void RenderRasterParticleLayer::update(gfx::ShaderRegistry& shaders, 0, maskMode, true); + const bool particlesBuilt = !resources->formalDisplay || + buildParticlePoints(context, + resources, + trailGroup, + getID() + "-static-bootstrap-trail-particles", + resources->stateTargets[stateWrite]->getTexture(), + resources->trailTargets[trailWrite]->getTexture(), + stateWrite, + trailWrite); compositeGroup.clearDrawables(); bool compositeBuilt = true; const auto center = transformState.getLatLng(LatLng::Unwrapped); @@ -1050,7 +1177,7 @@ void RenderRasterParticleLayer::update(gfx::ShaderRegistry& shaders, false) && compositeBuilt; } - if (!stateBuilt || !trailBuilt || !compositeBuilt) { + if (!stateBuilt || !trailBuilt || !particlesBuilt || !compositeBuilt) { compositeGroup.clearDrawables(); return; } @@ -1136,6 +1263,15 @@ void RenderRasterParticleLayer::update(gfx::ShaderRegistry& shaders, 0, maskMode, true); + const bool particlesBuilt = !resources->formalDisplay || + buildParticlePoints(context, + resources, + trailGroup, + getID() + "-trail-particles", + resources->stateTargets[stateWrite]->getTexture(), + resources->trailTargets[trailWrite]->getTexture(), + stateWrite, + trailWrite); compositeGroup.clearDrawables(); bool compositeBuilt = true; const auto center = transformState.getLatLng(LatLng::Unwrapped); @@ -1158,7 +1294,7 @@ void RenderRasterParticleLayer::update(gfx::ShaderRegistry& shaders, false) && compositeBuilt; } - if (!stateBuilt || !trailBuilt || !compositeBuilt) { + if (!stateBuilt || !trailBuilt || !particlesBuilt || !compositeBuilt) { compositeGroup.clearDrawables(); return; } diff --git a/粒子开发记录.md b/粒子开发记录.md index 6afaa8d2b..40a4f6bbf 100644 --- a/粒子开发记录.md +++ b/粒子开发记录.md @@ -266,3 +266,11 @@ - 日志包含请求/实际 count、State grid、State target create/rebuild/release 和拒绝原因；Trail 继续用四个确定性 State texel作低开销可视健康指示，实际并行 simulation 数仍是整个 State 网格。 - Linux OpenGL 受影响 Core 和新增 Layer test object 精确编译、C++ format、diff check 均通过；未运行 Android Gradle、ADB、APK 或设备，也未加入 Jest。 - 当前状态只能是 `IMPLEMENTED / WAITING FOR ANDROID VALIDATION`。用户将以 x86_64 Android OpenGL 逐档填写容量矩阵后，才能确定稳定区间、性能下降区间和压力边界。 + +## 2026-09-03 — 40-03 Full Particle Draw 补齐（STEP-044 v2） + +- 暂停 v1 容量验收的根因已补齐：v1 的 State A/B 虽可容纳 N 个 State texel，但 Trail fragment 只读取四个固定 sample，实际 Trail draw 只是全屏 quad，不能证明 N 个粒子已绘制。 +- 正式 RasterParticle Trail 现在先保留既有全屏 fade，再在同一 Trail A/B write target 绘制 N 个 point。particle index 在资源创建/count change 时一次性映射到 State texel `(x,y)`；vertex shader 每帧直接从当前 State write texture fetch RG position，Composite 仍消费 Trail write。没有 CPU readback、每帧 CPU position loop、第二 simulation 或 overlay。 +- 16-bit index buffer 每 segment 最多 65,536 point；1M 使用多个 segment，但继续走同一 State→Trail→Composite GPU path。日志明确输出 `trailDrawCount`、`particleIndexCount` 与 `fullParticleDraw=true`；legacy validation 的四 sample 诊断保留且不再限制正式层。 +- U/V、Mercator `dy=-v`、T0/T1、MIX、Field reuse、seed/lifecycle 和 Android JNI 均未改变。Linux OpenGL 精确 Core/test object 编译、shader generator 二次幂等、format 与 diff check 通过；未运行 Android Gradle、ADB、设备或 Jest。 +- 状态继续为 `IMPLEMENTED / WAITING FOR ANDROID VALIDATION`，用户下一轮只验收 256、1K、256→1K→256 的 full draw 正确性，之后才恢复完整容量矩阵。