perf(android): all-in-one Android scene is GPU-bound at ~20 FPS on Mali-G720 #1073

Closed
opened 2026-11-07 02:05:56 +00:00 by SakulFlee · 23 comments
Owner

Regression data

Device GPU Before hybrid With hybrid
Phone Mali-G720 ~130 FPS ~9 FPS
Tablet Adreno 810 ~60-80 FPS ~3 FPS

The regression is not Mali-specific: Adreno drops by roughly 20-27x as well. The hybrid renderer is the common change.

Capture notes

  • The user moved around, looked at lights, and opened/closed the UI where possible.
  • Phone runs at ~9 FPS, so interaction is limited.
  • Tablet runs at ~3 FPS and cannot run iced because it lacks SHADER_F16 (#1074), so its captures are scene-only.
  • Windows/Linux shows the hybrid renderer is GPU-bound on weaker GPUs; Android needs the same per-pass breakdown.

Blockers

  • GPU timestamp readback can go stale, so GPU columns need validation (#1076).
  • The CSV lacks resolution, refresh, present mode, render scale, and feature settings (#1078).

Investigation

  • Capture the phone and tablet with the same scene and settings.
  • Record resolution, render scale, AA, deferred, volumetrics, bloom/glare, and present mode.
  • Compare hybrid vs pre-hybrid on the same device if an old build is available.
  • Break down GPU cost by shadow, models, deferred lighting, volumetrics, tonemap, and AA.
  • Check whether the cost is resolution/bandwidth-bound or pass-specific.
  • Check the related Linux hybrid regression (#1081) for the same pattern.

Acceptance criteria

  • A trustworthy per-stage breakdown exists for both devices.
  • The dominant cost is identified.
  • Follow-up optimization issues are created with measured targets, or the regression is fixed.
## Regression data | Device | GPU | Before hybrid | With hybrid | |---|---|---|---| | Phone | Mali-G720 | ~130 FPS | ~9 FPS | | Tablet | Adreno 810 | ~60-80 FPS | ~3 FPS | The regression is not Mali-specific: Adreno drops by roughly 20-27x as well. The hybrid renderer is the common change. ## Capture notes - The user moved around, looked at lights, and opened/closed the UI where possible. - Phone runs at ~9 FPS, so interaction is limited. - Tablet runs at ~3 FPS and cannot run iced because it lacks `SHADER_F16` (#1074), so its captures are scene-only. - Windows/Linux shows the hybrid renderer is GPU-bound on weaker GPUs; Android needs the same per-pass breakdown. ## Blockers - GPU timestamp readback can go stale, so GPU columns need validation (#1076). - The CSV lacks resolution, refresh, present mode, render scale, and feature settings (#1078). ## Investigation - Capture the phone and tablet with the same scene and settings. - Record resolution, render scale, AA, deferred, volumetrics, bloom/glare, and present mode. - Compare hybrid vs pre-hybrid on the same device if an old build is available. - Break down GPU cost by shadow, models, deferred lighting, volumetrics, tonemap, and AA. - Check whether the cost is resolution/bandwidth-bound or pass-specific. - Check the related Linux hybrid regression (#1081) for the same pattern. ## Acceptance criteria - A trustworthy per-stage breakdown exists for both devices. - The dominant cost is identified. - Follow-up optimization issues are created with measured targets, or the regression is fixed.
SakulFlee changed title from perf(android): investigate ~9 FPS on Mali-G720 with hybrid renderer to perf(android): hybrid renderer drops Mali-G720 to ~9 FPS and Adreno 810 to ~3 FPS 2026-11-07 03:29:43 +00:00
Author
Owner

Phone CSV attached above. The steady-state result is clearly present-bound, not label/SDF-bound and not primarily iced:

  • 65 rows over ~72 s; stable FPS ~8-9
  • cdt median 120.4 ms
  • surface_acq median 0.61 ms
  • update 13.62 ms (ui_events 13.26 ms)
  • scene_submit 6.16 ms
  • overlay_layers 5.94 ms (iced_draw 1.03 ms, iced_submit 4.78 ms)
  • total 106.47 ms
  • present median 88.85 ms, mean 83.7 ms

update + surface_acq + total is 120.7 ms and matches the 120.4 ms CDT, so the low FPS is real. present alone caps the phone at roughly 11 FPS; the remaining CPU work brings it down to ~8.

The GPU columns cannot currently explain it: gpu_scene_total reports ~1 ms, then all GPU stages become zero after row 48 while present stays around 89 ms. That is inconsistent with a real 1 ms GPU frame and is tracked in #1076. The real GPU work must be at least on the order of the present wait.

This also means:

  • SDF/labels are not the cause of the steady-state 8 FPS. The startup ANR is separate (#1072).
  • Iced submit is a secondary cost; the tablet reaches ~3 FPS without iced at all (#1074).
  • The next useful data is the tablet CSV and a real GPU/swapchain profile.

Suggested A/B next:

  • hybrid/deferred off vs on
  • volumetrics off vs on
  • AA off / FXAA / SMAA
  • lower render scale or window resolution
  • Mailbox vs Fifo present mode
  • debug UI hidden vs visible
  • Android GPU profiler (Perfetto / Arm Streamline) to separate GPU execution from present/compositor stall
Phone CSV attached above. The steady-state result is clearly **present-bound**, not label/SDF-bound and not primarily iced: - 65 rows over ~72 s; stable FPS ~8-9 - `cdt` median 120.4 ms - `surface_acq` median 0.61 ms - `update` 13.62 ms (`ui_events` 13.26 ms) - `scene_submit` 6.16 ms - `overlay_layers` 5.94 ms (`iced_draw` 1.03 ms, `iced_submit` 4.78 ms) - `total` 106.47 ms - **`present` median 88.85 ms**, mean 83.7 ms `update + surface_acq + total` is 120.7 ms and matches the 120.4 ms CDT, so the low FPS is real. `present` alone caps the phone at roughly 11 FPS; the remaining CPU work brings it down to ~8. The GPU columns cannot currently explain it: `gpu_scene_total` reports ~1 ms, then all GPU stages become zero after row 48 while `present` stays around 89 ms. That is inconsistent with a real 1 ms GPU frame and is tracked in #1076. The real GPU work must be at least on the order of the present wait. This also means: - SDF/labels are not the cause of the steady-state 8 FPS. The startup ANR is separate (#1072). - Iced submit is a secondary cost; the tablet reaches ~3 FPS without iced at all (#1074). - The next useful data is the tablet CSV and a real GPU/swapchain profile. Suggested A/B next: - hybrid/deferred off vs on - volumetrics off vs on - AA off / FXAA / SMAA - lower render scale or window resolution - Mailbox vs Fifo present mode - debug UI hidden vs visible - Android GPU profiler (Perfetto / Arm Streamline) to separate GPU execution from present/compositor stall
Author
Owner

Tablet CSV attached. It confirms that iced is not the primary cause: the tablet has no iced at all and still runs at ~2-3 FPS.

Stable medians (rows 3+):

  • FPS: 3
  • cdt: 368.0 ms
  • update: 0.49 ms
  • ui_events: 0.045 ms
  • overlay_layers: 0.047 ms
  • iced_draw / iced_submit: 0.000 / 0.000
  • surface_acq: 0.52 ms
  • realize: 4.54 ms
  • scene_encode: 2.94 ms
  • scene_submit: 16.22 ms
  • total: 367.71 ms
  • present: 342.33 ms

update + surface_acq + total is 368.7 ms and matches the 368.0 ms CDT. present is 93% of total and 93% of the full frame. The tablet is present-bound in the same way as the phone, just much worse.

Phone vs tablet:

Phone Mali-G720 Tablet Adreno 810
FPS ~8 ~3
present ~89 ms ~342 ms
update 13.62 ms (iced) 0.49 ms (no iced)
iced_submit 4.78 ms 0.00 ms
GPU columns ~1 ms, then zero constant 3.149/4.876

The GPU columns are again unusable: gpu_scene_total stays at 3.149 ms and gpu_volumetrics at 4.876 ms for 91 rows, while present is 342 ms. That is the stale readback in #1076.

Conclusion: both Android devices point to a real present/GPU stall, not labels, iced, or surface acquisition. The tablet is the cleanest data point because iced is completely absent.

Next useful tests:

  • GPU profiler (Perfetto / Arm Streamline) to separate GPU execution from present/compositor stall.
  • hybrid/deferred off vs on.
  • volumetrics off vs on.
  • lower render scale / resolution.
  • Mailbox vs Fifo present mode.
  • record resolution, render scale, and refresh rate; currently missing (#1078).
Tablet CSV attached. It confirms that iced is not the primary cause: the tablet has no iced at all and still runs at ~2-3 FPS. Stable medians (rows 3+): - FPS: 3 - `cdt`: 368.0 ms - `update`: 0.49 ms - `ui_events`: 0.045 ms - `overlay_layers`: 0.047 ms - `iced_draw` / `iced_submit`: 0.000 / 0.000 - `surface_acq`: 0.52 ms - `realize`: 4.54 ms - `scene_encode`: 2.94 ms - `scene_submit`: 16.22 ms - `total`: 367.71 ms - **`present`: 342.33 ms** `update + surface_acq + total` is 368.7 ms and matches the 368.0 ms CDT. `present` is 93% of `total` and 93% of the full frame. The tablet is present-bound in the same way as the phone, just much worse. Phone vs tablet: | | Phone Mali-G720 | Tablet Adreno 810 | |---|---:|---:| | FPS | ~8 | ~3 | | `present` | ~89 ms | ~342 ms | | `update` | 13.62 ms (iced) | 0.49 ms (no iced) | | `iced_submit` | 4.78 ms | 0.00 ms | | GPU columns | ~1 ms, then zero | constant 3.149/4.876 | The GPU columns are again unusable: `gpu_scene_total` stays at 3.149 ms and `gpu_volumetrics` at 4.876 ms for 91 rows, while `present` is 342 ms. That is the stale readback in #1076. Conclusion: both Android devices point to a real present/GPU stall, not labels, iced, or surface acquisition. The tablet is the cleanest data point because iced is completely absent. Next useful tests: - GPU profiler (Perfetto / Arm Streamline) to separate GPU execution from present/compositor stall. - hybrid/deferred off vs on. - volumetrics off vs on. - lower render scale / resolution. - Mailbox vs Fifo present mode. - record resolution, render scale, and refresh rate; currently missing (#1078).
Author
Owner

A practical blocker for the next A/B runs: on the phone the Rendering panel is off-screen, and the mobile "Debug" toggle can become unreachable when an off-screen panel still counts as visible. That is tracked in #1082. Fixing the small-screen layout/recovery path is needed before we can reliably toggle hybrid, volumetrics, AA, and render-scale settings on the device.

A practical blocker for the next A/B runs: on the phone the Rendering panel is off-screen, and the mobile "Debug" toggle can become unreachable when an off-screen panel still counts as visible. That is tracked in #1082. Fixing the small-screen layout/recovery path is needed before we can reliably toggle hybrid, volumetrics, AA, and render-scale settings on the device.
Author
Owner

Minimal phone CSV attached. This changes the interpretation significantly.

With the debug UI hidden (rows 1-6):

  • FPS: ~55-61 (minimal uses vsync_enabled: true, so 60 is the cap)
  • iced_draw: ~0.05 ms
  • iced_submit: ~0.96 ms
  • overlay_layers: ~1.05 ms
  • update: ~0.25 ms
  • present: ~0.8-2.7 ms
  • gpu_scene_total: ~0.14 ms
  • total: ~9 ms

With the debug UI open (rows 50-84):

  • FPS: ~39
  • iced_draw: ~10.4 ms
  • iced_submit: ~4.8 ms
  • overlay_layers: ~15.3 ms
  • ui_events: ~5.4 ms
  • update: ~5.6 ms
  • present: ~0.76 ms
  • gpu_scene_total: ~0.12 ms
  • total: ~19.7 ms

So the minimal example is not GPU- or present-bound at all. It is iced/debug-UI-bound: opening the UI adds roughly 18-20 ms per frame and drops it from the 60 FPS cap to ~40 FPS.

This means:

  • The AiO phone/tablet present plateau (89/342 ms) is not a generic Android present problem. The same phone can present a trivial scene in under 1 ms.
  • The AiO regression is likely heavy scene/hybrid GPU work or swapchain backpressure under that load, not the present path by itself.
  • Running performance captures with the debug UI open materially changes the result. The performance panel costs more than the entire minimal scene.
  • A tablet minimal run is still useful: if it is also fast, the AiO issue is scene/hybrid; if it is 3 FPS, then the tablet/surface path is separately broken.

This also strongly supports the small-screen tabbed layout in #1082 and broadening #1079 from idle submit to active panel cost.

Minimal phone CSV attached. This changes the interpretation significantly. With the debug UI hidden (rows 1-6): - FPS: ~55-61 (minimal uses `vsync_enabled: true`, so 60 is the cap) - `iced_draw`: ~0.05 ms - `iced_submit`: ~0.96 ms - `overlay_layers`: ~1.05 ms - `update`: ~0.25 ms - `present`: ~0.8-2.7 ms - `gpu_scene_total`: ~0.14 ms - `total`: ~9 ms With the debug UI open (rows 50-84): - FPS: ~39 - `iced_draw`: ~10.4 ms - `iced_submit`: ~4.8 ms - `overlay_layers`: ~15.3 ms - `ui_events`: ~5.4 ms - `update`: ~5.6 ms - `present`: ~0.76 ms - `gpu_scene_total`: ~0.12 ms - `total`: ~19.7 ms So the minimal example is not GPU- or present-bound at all. It is **iced/debug-UI-bound**: opening the UI adds roughly 18-20 ms per frame and drops it from the 60 FPS cap to ~40 FPS. This means: - The AiO phone/tablet `present` plateau (89/342 ms) is **not a generic Android present problem**. The same phone can present a trivial scene in under 1 ms. - The AiO regression is likely heavy scene/hybrid GPU work or swapchain backpressure under that load, not the present path by itself. - Running performance captures with the debug UI open materially changes the result. The performance panel costs more than the entire minimal scene. - A tablet minimal run is still useful: if it is also fast, the AiO issue is scene/hybrid; if it is 3 FPS, then the tablet/surface path is separately broken. This also strongly supports the small-screen tabbed layout in #1082 and broadening #1079 from idle submit to active panel cost.
Author
Owner

New branch capture attached: 589 rows over ~635 s, stable ~9.3 FPS.

Stable rows (UI panels hidden for 554 of 584 stable samples; only World2D|Orbital UI|UI|Debug visible):

  • surface_acq: 0.42 ms
  • update: 0.44 ms median
  • scene_submit: 12.90 ms median
  • present: 85.89 ms median
  • total: 106.50 ms median
  • frame_gap: 1.40 ms
  • gpu_complete: 195.54 ms median
  • gpu_scene_total: 1.09 ms (still stale/constant)
  • iced_draw / iced_submit: 0.04 / 0.76 ms

update + surface_acq + total + frame_limiter + frame_gap matches cdt (~108.8 ms). The debug UI is not running in the stable segment.

The key new signal is gpu_complete: ~195 ms, about 1.8× the 107 ms frame period, and it correlates 0.988 with present. With a queue depth of two frames, that corresponds to roughly ~97 ms of GPU work per frame, i.e. the frame period. This points to a heavily backed-up GPU queue, not a CPU or surface-acquisition bottleneck.

Caveat: gpu_complete is a queue-completion latency, not a per-frame GPU duration; it includes prior queued frames. So it does not yet tell us which GPU pass is responsible. gpu_scene_total/gpu_volumetrics are still stale (1.09/0.15 ms), so pass-level attribution still needs #1076 or a GPU profiler.

Phone/tablet confirmation and the performance_meta.json sidecar are still needed. The presence of iced and the layer names suggests the phone, but the metadata will confirm resolution, refresh, present mode and frame latency.

New branch capture attached: 589 rows over ~635 s, stable ~9.3 FPS. Stable rows (UI panels hidden for 554 of 584 stable samples; only `World2D|Orbital UI|UI|Debug` visible): - `surface_acq`: 0.42 ms - `update`: 0.44 ms median - `scene_submit`: 12.90 ms median - `present`: 85.89 ms median - `total`: 106.50 ms median - `frame_gap`: 1.40 ms - `gpu_complete`: **195.54 ms median** - `gpu_scene_total`: 1.09 ms (still stale/constant) - `iced_draw` / `iced_submit`: 0.04 / 0.76 ms `update + surface_acq + total + frame_limiter + frame_gap` matches `cdt` (~108.8 ms). The debug UI is not running in the stable segment. The key new signal is `gpu_complete`: **~195 ms**, about **1.8× the 107 ms frame period**, and it correlates 0.988 with `present`. With a queue depth of two frames, that corresponds to roughly ~97 ms of GPU work per frame, i.e. the frame period. This points to a heavily backed-up GPU queue, not a CPU or surface-acquisition bottleneck. Caveat: `gpu_complete` is a queue-completion latency, not a per-frame GPU duration; it includes prior queued frames. So it does not yet tell us which GPU pass is responsible. `gpu_scene_total`/`gpu_volumetrics` are still stale (1.09/0.15 ms), so pass-level attribution still needs #1076 or a GPU profiler. Phone/tablet confirmation and the `performance_meta.json` sidecar are still needed. The presence of iced and the layer names suggests the phone, but the metadata will confirm resolution, refresh, present mode and frame latency.
Author
Owner

Phone capture attached with metadata. Key numbers:

  • Mali-G720 MC7, 1220 x 2582 surface, 3.25 scale factor
  • present mode AutoNoVsync (supported: Mailbox, Fifo), vsync off, desired frame latency 2
  • SMAA High, deferred, volumetrics Low
  • 76 models, 17 lights, 8 shadow casters

Stable UI-hidden rows (39 samples, before the panels were opened):

  • FPS: ~9.05
  • cdt: ~108.8 ms
  • surface_acq: 0.43 ms
  • update: 0.50 ms
  • scene_submit: 6.8 ms median
  • present: 93.3 ms mean
  • total: 106.9 ms mean
  • gpu_complete: 202.3 ms mean
  • gpu_scene_total: ~0.2-1.1 ms; still stale

With the debug panels open (28 samples):

  • FPS: ~7.6
  • update: 14.1 ms
  • iced_submit: 6.6 ms mean
  • present: 95.2 ms
  • gpu_complete: 222.8 ms
  • total: 118.0 ms

So the UI costs frames, but the baseline is still ~9 FPS with the UI hidden. gpu_complete remains ~1.8–1.9× the frame period, consistent with the GPU queue being the limiter.

The phone orientation change is not represented in the CSV: the metadata sidecar is only the startup snapshot and there are no per-row width/height/orientation/refresh fields. That is now a concrete requirement under #1083.

The attached tablet files are not a tablet run: the tablet metadata reports the same phone model, Mali-G720, 1220 x 2582 and OS as the phone, and the tablet CSV is byte-identical to the earlier phone capture. A real tablet capture is still needed.

Phone capture attached with metadata. Key numbers: - Mali-G720 MC7, 1220 x 2582 surface, 3.25 scale factor - present mode `AutoNoVsync` (supported: `Mailbox`, `Fifo`), vsync off, desired frame latency 2 - SMAA High, deferred, volumetrics Low - 76 models, 17 lights, 8 shadow casters Stable UI-hidden rows (39 samples, before the panels were opened): - FPS: ~9.05 - `cdt`: ~108.8 ms - `surface_acq`: 0.43 ms - `update`: 0.50 ms - `scene_submit`: 6.8 ms median - `present`: 93.3 ms mean - `total`: 106.9 ms mean - `gpu_complete`: 202.3 ms mean - `gpu_scene_total`: ~0.2-1.1 ms; still stale With the debug panels open (28 samples): - FPS: ~7.6 - `update`: 14.1 ms - `iced_submit`: 6.6 ms mean - `present`: 95.2 ms - `gpu_complete`: 222.8 ms - `total`: 118.0 ms So the UI costs frames, but the baseline is still ~9 FPS with the UI hidden. `gpu_complete` remains ~1.8–1.9× the frame period, consistent with the GPU queue being the limiter. The phone orientation change is not represented in the CSV: the metadata sidecar is only the startup snapshot and there are no per-row width/height/orientation/refresh fields. That is now a concrete requirement under #1083. The attached tablet files are not a tablet run: the tablet metadata reports the same phone model, Mali-G720, 1220 x 2582 and OS as the phone, and the tablet CSV is byte-identical to the earlier phone capture. A real tablet capture is still needed.
Author
Owner

Real tablet capture confirmed: Adreno 810, 2560 x 1600, scale factor 2.0, Android 16 on 2509ARPBDG, no iced (Orbital UI hidden, iced draw/submit = 0).

Short but stable run (17 usable samples, ~3 FPS):

  • FPS: 2.71
  • cdt: 358.6 ms median
  • surface_acq: 0.41 ms
  • update: 0.49 ms
  • scene_submit: 14.3 ms median
  • present: 290.8 ms mean / 327.2 ms median
  • total: 351.7 ms mean / 352.9 ms median
  • gpu_complete: 566.7 ms mean / 678.4 ms median
  • gpu_scene_total: 0.0 ms
  • iced_draw / iced_submit: 0 / 0

The phone/tablet comparison:

Phone Mali-G720 Tablet Adreno 810
Surface 1220 x 2582 2560 x 1600
FPS ~9.0 ~2.7
Frame period ~109 ms ~358 ms
present ~93 ms ~291 ms
gpu_complete ~202 ms ~567 ms
gpu_complete / frame ~1.85 ~1.7
Iced yes no

Both devices show ~1.7-1.9x frame-period GPU completion latency, consistent with the configured two-frame queue. The tablet has no iced at all, so the ~3 FPS is not UI-related. This is strong evidence that both Android devices are GPU/queue-bound.

The tablet pass timestamps are unusable (gpu_scene_total is all zero), so pass attribution still needs #1076 or a GPU profiler. Resolution/refresh still need normalization (#1083).

Real tablet capture confirmed: Adreno 810, 2560 x 1600, scale factor 2.0, Android 16 on 2509ARPBDG, no iced (`Orbital UI` hidden, iced draw/submit = 0). Short but stable run (17 usable samples, ~3 FPS): - FPS: 2.71 - `cdt`: 358.6 ms median - `surface_acq`: 0.41 ms - `update`: 0.49 ms - `scene_submit`: 14.3 ms median - `present`: 290.8 ms mean / 327.2 ms median - `total`: 351.7 ms mean / 352.9 ms median - `gpu_complete`: 566.7 ms mean / 678.4 ms median - `gpu_scene_total`: 0.0 ms - `iced_draw` / `iced_submit`: 0 / 0 The phone/tablet comparison: | | Phone Mali-G720 | Tablet Adreno 810 | |---|---:|---:| | Surface | 1220 x 2582 | 2560 x 1600 | | FPS | ~9.0 | ~2.7 | | Frame period | ~109 ms | ~358 ms | | `present` | ~93 ms | ~291 ms | | `gpu_complete` | ~202 ms | ~567 ms | | `gpu_complete / frame` | ~1.85 | ~1.7 | | Iced | yes | no | Both devices show ~1.7-1.9x frame-period GPU completion latency, consistent with the configured two-frame queue. The tablet has no iced at all, so the ~3 FPS is not UI-related. This is strong evidence that both Android devices are GPU/queue-bound. The tablet pass timestamps are unusable (`gpu_scene_total` is all zero), so pass attribution still needs #1076 or a GPU profiler. Resolution/refresh still need normalization (#1083).
Author
Owner

Real tablet native vs quarter-resolution comparison (same Adreno 810, no iced, UI hidden):

Tablet native Tablet 1280x800
Pixels 4.10M 1.02M
FPS 2.63 8.25
Frame period ~372 ms ~111 ms
present ~325 ms ~92 ms
gpu_complete ~680 ms ~204 ms
surface_acq 0.60 ms 0.61 ms
update 0.87 ms 0.72 ms
scene_submit 17.4 ms 12.3 ms

Quarter resolution is 4x fewer pixels and the frame/GPU completion times improved by roughly 3.3-3.4x. That is strong evidence for a pixel/fill-rate/bandwidth-bound workload on the tablet.

This also confirms the earlier tablet files were mislabelled; the attached native/quarter files are the real tablet runs.

The phone baseline at 1220x2582 is ~9 FPS; the tablet at 1280x800 reaches ~8.3 FPS. The tablet's GPU is substantially weaker, but resolution scaling can make it much more usable. The tablet remains GPU/queue-bound at both resolutions (gpu_complete / frame ~1.8-1.9), so adaptive render scale is a valid mitigation but not a complete fix.

The Perfetto trace confirms the tablet is running at a 48 Hz active display mode (supported 120/90/60/50/48/30), while winit reports refresh 0. Thermal status is 0 with GPU around 40 C, so thermal throttling is not the cause. gpu_counter_track is empty and the native app has no HWUI frame timeline (gfxinfo reports 0 frames), so the trace still cannot identify the GPU pass.

Real tablet native vs quarter-resolution comparison (same Adreno 810, no iced, UI hidden): | | Tablet native | Tablet 1280x800 | |---|---:|---:| | Pixels | 4.10M | 1.02M | | FPS | 2.63 | 8.25 | | Frame period | ~372 ms | ~111 ms | | `present` | ~325 ms | ~92 ms | | `gpu_complete` | ~680 ms | ~204 ms | | `surface_acq` | 0.60 ms | 0.61 ms | | `update` | 0.87 ms | 0.72 ms | | `scene_submit` | 17.4 ms | 12.3 ms | Quarter resolution is 4x fewer pixels and the frame/GPU completion times improved by roughly 3.3-3.4x. That is strong evidence for a pixel/fill-rate/bandwidth-bound workload on the tablet. This also confirms the earlier tablet files were mislabelled; the attached native/quarter files are the real tablet runs. The phone baseline at 1220x2582 is ~9 FPS; the tablet at 1280x800 reaches ~8.3 FPS. The tablet's GPU is substantially weaker, but resolution scaling can make it much more usable. The tablet remains GPU/queue-bound at both resolutions (`gpu_complete / frame ~1.8-1.9`), so adaptive render scale is a valid mitigation but not a complete fix. The Perfetto trace confirms the tablet is running at a 48 Hz active display mode (supported 120/90/60/50/48/30), while winit reports refresh 0. Thermal status is 0 with GPU around 40 C, so thermal throttling is not the cause. `gpu_counter_track` is empty and the native app has no HWUI frame timeline (`gfxinfo` reports 0 frames), so the trace still cannot identify the GPU pass.
Author
Owner

Minimal tablet data attached. Assuming this is the minimal scene (metadata shows 4 entities, 2 models, 1 light), it is not equally bad at native resolution:

  • 2560 x 1600, Adreno 810, vsync on / AutoVsync
  • FPS: ~33 (median 34)
  • frame: ~29.5 ms
  • present: ~11 ms
  • gpu_complete: ~42 ms
  • update: ~0.55 ms
  • scene_submit: ~9.6 ms
  • scene_encode: ~3.2 ms
  • iced: 0
  • gpu_scene_total: 0 (old timestamp bug)

Compare with AiO native on the same tablet: ~2.6 FPS / ~372 ms frame. Minimal is roughly 12x faster.

This means scene/render workload complexity absolutely does matter. The earlier assumption that minimal was equally bad is not supported by this capture. The tablet can render the trivial scene at ~33 FPS at 2560x1600; AiO at the same resolution is ~2.6 FPS.

If you meant a different minimal run, please send that CSV/meta too. This one points back at the AiO GPU workload rather than a generic Android present/swapchain limit.

Minimal tablet data attached. Assuming this is the minimal scene (metadata shows 4 entities, 2 models, 1 light), it is **not** equally bad at native resolution: - 2560 x 1600, Adreno 810, vsync on / AutoVsync - FPS: ~33 (median 34) - frame: ~29.5 ms - `present`: ~11 ms - `gpu_complete`: ~42 ms - `update`: ~0.55 ms - `scene_submit`: ~9.6 ms - `scene_encode`: ~3.2 ms - `iced`: 0 - `gpu_scene_total`: 0 (old timestamp bug) Compare with AiO native on the same tablet: ~2.6 FPS / ~372 ms frame. Minimal is roughly **12x faster**. This means scene/render workload complexity absolutely does matter. The earlier assumption that minimal was equally bad is not supported by this capture. The tablet can render the trivial scene at ~33 FPS at 2560x1600; AiO at the same resolution is ~2.6 FPS. If you meant a different minimal run, please send that CSV/meta too. This one points back at the AiO GPU workload rather than a generic Android present/swapchain limit.
Author
Owner

Emulator run with the timestamp fix is useful. It is llvmpipe/CPU, not tablet hardware, but the pass breakdown is now nonzero:

  • gpu_scene_total: ~89 ms
  • gpu_shadow: ~30 ms
  • gpu_skybox: ~2.6 ms
  • gpu_models: ~57 ms
  • gpu_volumetrics: ~130 ms
  • gpu_tonemap: ~14 ms
  • gpu_aa: ~8 ms
  • gpu_complete: ~245 ms
  • frame: ~272 ms
  • present: ~1 ms

So on this software renderer, volumetrics is the largest pass, followed by models and shadows. present is negligible, and CPU update is ~0.17 ms. This is evidence that the hybrid scene GPU workload is the problem, not present/swapchain, and it finally gives us pass attribution.

The emulator resolution is only 320x640; we need the tablet/phone run on the new build to see whether volumetrics is also dominant on Adreno/Mali. If it is, the regression is likely in the volumetric/hybrid path rather than Android presentation.

Emulator run with the timestamp fix is useful. It is llvmpipe/CPU, not tablet hardware, but the pass breakdown is now nonzero: - `gpu_scene_total`: ~89 ms - `gpu_shadow`: ~30 ms - `gpu_skybox`: ~2.6 ms - `gpu_models`: ~57 ms - `gpu_volumetrics`: ~130 ms - `gpu_tonemap`: ~14 ms - `gpu_aa`: ~8 ms - `gpu_complete`: ~245 ms - frame: ~272 ms - `present`: ~1 ms So on this software renderer, volumetrics is the largest pass, followed by models and shadows. `present` is negligible, and CPU update is ~0.17 ms. This is evidence that the hybrid scene GPU workload is the problem, not present/swapchain, and it finally gives us pass attribution. The emulator resolution is only 320x640; we need the tablet/phone run on the new build to see whether volumetrics is also dominant on Adreno/Mali. If it is, the regression is likely in the volumetric/hybrid path rather than Android presentation.
Author
Owner

Phone capture with the fixed GPU timestamp readback (Mali-G720, 1220 x 2582, UI hidden, ~8.2 FPS):

Pass Mean
gpu_scene_total ~92.9 ms
gpu_shadow ~1.08 ms
gpu_skybox ~1.21 ms
gpu_models ~90.6 ms
gpu_volumetrics ~14.2 ms
gpu_tonemap ~6.7 ms
gpu_aa ~1.6 ms
gpu_complete ~228 ms
present ~105.5 ms
frame ~122 ms

The pass sum is roughly the frame time, and CPU is not the bottleneck (update ~0.5 ms, scene_submit ~7.4 ms). The frame is GPU-bound.

The largest bucket is gpu_models, which currently contains G-buffer, light culling, deferred lighting, forward opaque models and transparent models. That bucket is ~90 ms; volumetrics is only ~14 ms on the phone. So unlike llvmpipe, the phone hotspot is the scene/deferred/model group, not primarily volumetrics.

The timestamps are now nonzero and coherent, so #1076 is fixed on this device. The next step is to split gpu_models into its subpasses (G-buffer / light culling / deferred lighting / models / transparent) to identify the exact cost.

Phone capture with the fixed GPU timestamp readback (Mali-G720, 1220 x 2582, UI hidden, ~8.2 FPS): | Pass | Mean | |---|---:| | `gpu_scene_total` | ~92.9 ms | | `gpu_shadow` | ~1.08 ms | | `gpu_skybox` | ~1.21 ms | | `gpu_models` | **~90.6 ms** | | `gpu_volumetrics` | ~14.2 ms | | `gpu_tonemap` | ~6.7 ms | | `gpu_aa` | ~1.6 ms | | `gpu_complete` | ~228 ms | | `present` | ~105.5 ms | | frame | ~122 ms | The pass sum is roughly the frame time, and CPU is not the bottleneck (`update` ~0.5 ms, `scene_submit` ~7.4 ms). The frame is GPU-bound. The largest bucket is `gpu_models`, which currently contains G-buffer, light culling, deferred lighting, forward opaque models and transparent models. That bucket is ~90 ms; volumetrics is only ~14 ms on the phone. So unlike llvmpipe, the phone hotspot is the **scene/deferred/model group**, not primarily volumetrics. The timestamps are now nonzero and coherent, so #1076 is fixed on this device. The next step is to split `gpu_models` into its subpasses (G-buffer / light culling / deferred lighting / models / transparent) to identify the exact cost.
Author
Owner

Phone capture with the Damaged Helmet loaded:

  • FPS: ~9.1
  • frame: ~107 ms
  • gpu_scene_total: ~82 ms
  • gpu_shadow: ~5.2 ms
  • gpu_skybox: ~1.1 ms
  • gpu_models: ~75.9 ms
  • gpu_volumetrics: ~12.6 ms
  • gpu_tonemap: ~6.1 ms
  • gpu_aa: ~1.6 ms
  • gpu_complete: ~196 ms

The helmet loads and raises shadow cost (1.1 -> 5.2 ms), but the dominant bucket is still gpu_models at ~76 ms. The missing helmet was not the cause of the low FPS.

I added subpass timestamps on feat/perf-timings (commit 5be0937d):

  • gpu_gbuffer
  • gpu_light_culling
  • gpu_deferred
  • gpu_models now means forward opaque models
  • gpu_transparent
  • gpu_scene_total remains the aggregate

Rebuild and capture the tablet/phone again; the ~76-90 ms bucket should now split into the actual deferred/hybrid cost.

Phone capture with the Damaged Helmet loaded: - FPS: ~9.1 - frame: ~107 ms - `gpu_scene_total`: ~82 ms - `gpu_shadow`: ~5.2 ms - `gpu_skybox`: ~1.1 ms - `gpu_models`: ~75.9 ms - `gpu_volumetrics`: ~12.6 ms - `gpu_tonemap`: ~6.1 ms - `gpu_aa`: ~1.6 ms - `gpu_complete`: ~196 ms The helmet loads and raises shadow cost (1.1 -> 5.2 ms), but the dominant bucket is still `gpu_models` at ~76 ms. The missing helmet was not the cause of the low FPS. I added subpass timestamps on `feat/perf-timings` (commit `5be0937d`): - `gpu_gbuffer` - `gpu_light_culling` - `gpu_deferred` - `gpu_models` now means forward opaque models - `gpu_transparent` - `gpu_scene_total` remains the aggregate Rebuild and capture the tablet/phone again; the ~76-90 ms bucket should now split into the actual deferred/hybrid cost.
Author
Owner

Fresh pass-level capture from feat/perf-timings @ 5be0937d on the phone (Mali-G720 MC7, 1220x2712, 17 lights, 8 shadow casters, deferred, SMAA High, volumetrics Low):

Stage Mean
FPS 9.59
frame 103.5 ms
gpu_scene_total 77.88 ms
gpu_deferred 73.66 ms
gpu_gbuffer 0.79 ms
gpu_light_culling 1.11 ms
gpu_models (forward opaque) 0.04 ms
gpu_transparent 0.05 ms
gpu_shadow 1.05 ms
gpu_skybox 1.18 ms
gpu_volumetrics 13.49 ms
gpu_tonemap 6.12 ms
gpu_aa 1.51 ms

The subpass sum matches gpu_scene_total exactly (77.88 ms). Deferred lighting is 94.6% of the scene total, so the old gpu_models bucket was overwhelmingly deferred lighting, not G-buffer geometry.

The previous black screen was not the timestamp code: the generated test project was stale and spawned the 8 SDF billboard labels during Module::setup because it lacked upstream commit 1182fd90 (the Android SDF guard). generate_sdf/SdfAtlas::build_atlas ran for ~35.6 billion inner iterations on the main thread before the first frame. The local project source was synced to the canonical all-in-one example; the timestamp build then rendered. The engine checkout remains clean at 5be0937d.

Follow-up optimization issue: #1085.

Fresh pass-level capture from `feat/perf-timings` @ `5be0937d` on the phone (Mali-G720 MC7, 1220x2712, 17 lights, 8 shadow casters, deferred, SMAA High, volumetrics Low): | Stage | Mean | |---|---:| | FPS | 9.59 | | frame | 103.5 ms | | `gpu_scene_total` | 77.88 ms | | `gpu_deferred` | **73.66 ms** | | `gpu_gbuffer` | 0.79 ms | | `gpu_light_culling` | 1.11 ms | | `gpu_models` (forward opaque) | 0.04 ms | | `gpu_transparent` | 0.05 ms | | `gpu_shadow` | 1.05 ms | | `gpu_skybox` | 1.18 ms | | `gpu_volumetrics` | 13.49 ms | | `gpu_tonemap` | 6.12 ms | | `gpu_aa` | 1.51 ms | The subpass sum matches `gpu_scene_total` exactly (77.88 ms). Deferred lighting is 94.6% of the scene total, so the old `gpu_models` bucket was overwhelmingly deferred lighting, not G-buffer geometry. The previous black screen was not the timestamp code: the generated test project was stale and spawned the 8 SDF billboard labels during `Module::setup` because it lacked upstream commit `1182fd90` (the Android SDF guard). `generate_sdf`/`SdfAtlas::build_atlas` ran for ~35.6 billion inner iterations on the main thread before the first frame. The local project source was synced to the canonical all-in-one example; the timestamp build then rendered. The engine checkout remains clean at `5be0937d`. Follow-up optimization issue: #1085.
Author
Owner

Controlled phone A/B at native resolution (Mali-G720, 1220x2582, same scene/settings) changes the conclusion from “deferred pass” to “shared per-fragment lighting/shadow work”:

Variant Scene total Key observation
A: deferred baseline 78.00 ms gpu_deferred 73.61 ms
B: forward 71.19 ms forward opaque 66.46 ms; only 8.7% faster
C: deferred, 8 shadow casters disabled 36.25 ms gpu_deferred 33.15 ms
D: deferred, shadows off, only directional 7.00 ms gpu_deferred 4.01 ms

Approximate decomposition:

  • shadow sampling/PCF: ~40.5 ms/frame (A → C)
  • 16 point/spot light loop: ~29.1 ms/frame (C → D)
  • base fullscreen BRDF/IBL: ~4 ms/frame (D)

All four variants had exact subpass sums. The forward path is only ~6.8 ms faster than deferred, so fixing the deferred pass alone cannot recover the regression. The remaining work is in the shared per-fragment light/shadow path.

Follow-ups:

  • #1085 — umbrella: shared per-fragment lighting/shadow cost
  • #1086 — shadow sampling/PCF
  • #1087 — point/spot light loop and tiled-culling effectiveness
Controlled phone A/B at native resolution (Mali-G720, 1220x2582, same scene/settings) changes the conclusion from “deferred pass” to “shared per-fragment lighting/shadow work”: | Variant | Scene total | Key observation | |---|---:|---| | A: deferred baseline | 78.00 ms | `gpu_deferred` 73.61 ms | | B: forward | 71.19 ms | forward opaque 66.46 ms; only 8.7% faster | | C: deferred, 8 shadow casters disabled | 36.25 ms | `gpu_deferred` 33.15 ms | | D: deferred, shadows off, only directional | 7.00 ms | `gpu_deferred` 4.01 ms | Approximate decomposition: - shadow sampling/PCF: ~40.5 ms/frame (A → C) - 16 point/spot light loop: ~29.1 ms/frame (C → D) - base fullscreen BRDF/IBL: ~4 ms/frame (D) All four variants had exact subpass sums. The forward path is only ~6.8 ms faster than deferred, so fixing the deferred pass alone cannot recover the regression. The remaining work is in the shared per-fragment light/shadow path. Follow-ups: - #1085 — umbrella: shared per-fragment lighting/shadow cost - #1086 — shadow sampling/PCF - #1087 — point/spot light loop and tiled-culling effectiveness
Author
Owner

One important caveat on the original before/after comparison: switching the current build to the forward path gives 10.38 FPS, not ~130 FPS. The current forward path is only 8.7% faster than deferred, so the 130 FPS “before hybrid” number is not reproducible by simply disabling deferred now.

Before treating #1073 as a hybrid-only regression, verify the old 130 FPS capture on the same scene, resolution, AA, volumetrics, and light/shadow set (or on the pre-hybrid commit). The measured current bottleneck is shared per-fragment lighting/shadow work in both paths.

One important caveat on the original before/after comparison: switching the current build to the forward path gives 10.38 FPS, not ~130 FPS. The current forward path is only 8.7% faster than deferred, so the 130 FPS “before hybrid” number is not reproducible by simply disabling deferred now. Before treating #1073 as a hybrid-only regression, verify the old 130 FPS capture on the same scene, resolution, AA, volumetrics, and light/shadow set (or on the pre-hybrid commit). The measured current bottleneck is shared per-fragment lighting/shadow work in both paths.
Author
Owner

Root cause candidate from the batch: #1088. The light “range” packed into params.z is intensity / 0.01; the all-in-one intensities of 30–60 produce radii of ~55–77 world units. That makes every point/spot light global, so tiled culling is all-inclusive and most light/shadow work is evaluated everywhere.

This is consistent with:

  • PCF 9→1 saves only ~4 ms; shadow-map resolution has no effect.
  • Forced full-loop is not worse than tiled culling.
  • Removing the 8 R5 point lights saves ~31.9 ms.
  • Forward and deferred are both affected.

Next: temporary fixed range (e.g. 10 units) A/B before implementing the explicit range API.

Root cause candidate from the batch: #1088. The light “range” packed into `params.z` is `intensity / 0.01`; the all-in-one intensities of 30–60 produce radii of ~55–77 world units. That makes every point/spot light global, so tiled culling is all-inclusive and most light/shadow work is evaluated everywhere. This is consistent with: - PCF 9→1 saves only ~4 ms; shadow-map resolution has no effect. - Forced full-loop is not worse than tiled culling. - Removing the 8 R5 point lights saves ~31.9 ms. - Forward and deferred are both affected. Next: temporary fixed range (e.g. 10 units) A/B before implementing the explicit range API.
Author
Owner

Root cause fixed in b7086621: point/spot range is now explicit (default 10 world units), glTF range is supported, and the light range is no longer derived from intensity. A smooth range window replaces the hard cutoff.

The temporary fixed-range test reduced gpu_deferred from 73.83 to 21.26 ms at radius 10 and raised FPS from 9.50 to 20.00. Rebuild from b7086621 and capture the default-range scene; then re-run the culling and shadow experiments now that the tile lists should be sparse.

Root cause fixed in `b7086621`: point/spot range is now explicit (default 10 world units), glTF range is supported, and the light range is no longer derived from intensity. A smooth range window replaces the hard cutoff. The temporary fixed-range test reduced `gpu_deferred` from 73.83 to 21.26 ms at radius 10 and raised FPS from 9.50 to 20.00. Rebuild from `b7086621` and capture the default-range scene; then re-run the culling and shadow experiments now that the tile lists should be sparse.
SakulFlee changed title from perf(android): hybrid renderer drops Mali-G720 to ~9 FPS and Adreno 810 to ~3 FPS to perf(android): all-in-one Android scene is GPU-bound at ~20 FPS on Mali-G720 2026-11-10 02:47:47 +00:00
Author
Owner

b7086621 verified on the phone with the restored project (default range 10):

Metric Old global-range baseline b7086621
gpu_deferred 73.83 ms 21.24 ms
gpu_scene_total 78.13 ms 25.21 ms
FPS 9.50 20.19
frame 104.56 ms 49.01 ms

Culling now does real work (forced full loop: 24.85 ms deferred vs 21.24 tiled), the 8 shadow casters now cost ~4.4 ms instead of ~40.5 ms, and the hard light circles are gone with the smooth range window.

The original “130 FPS before hybrid” number predates the renderer rework and is not a valid comparison target. This issue now tracks the current all-in-one Android performance baseline rather than a hybrid-vs-forward regression.

`b7086621` verified on the phone with the restored project (default range 10): | Metric | Old global-range baseline | `b7086621` | |---|---:|---:| | `gpu_deferred` | 73.83 ms | 21.24 ms | | `gpu_scene_total` | 78.13 ms | 25.21 ms | | FPS | 9.50 | 20.19 | | frame | 104.56 ms | 49.01 ms | Culling now does real work (forced full loop: 24.85 ms deferred vs 21.24 tiled), the 8 shadow casters now cost ~4.4 ms instead of ~40.5 ms, and the hard light circles are gone with the smooth range window. The original “130 FPS before hybrid” number predates the renderer rework and is not a valid comparison target. This issue now tracks the current all-in-one Android performance baseline rather than a hybrid-vs-forward regression.
Author
Owner

Tablet A/B on the b7086621 build (Adreno 810, 2560x1600, same project/source):

Metric old 5be0937d new b7086621
FPS 3.00 4.50
frame 335.15 ms 219.91 ms
gpu_scene_total 100.13 ms 38.40 ms
gpu_deferred 76.43 ms 16.02 ms
gpu_volumetrics 213.00 ms 159.81 ms
gpu_light_culling 14.40 ms 13.08 ms

The range fix works on both vendors. The tablet is now dominated by volumetrics (~162 ms, ~74% of the frame), not deferred lighting or shadows. Follow-up #1089 covers the Adreno volumetric investigation and the tablet light-culling net-benefit check.

Tablet A/B on the `b7086621` build (Adreno 810, 2560x1600, same project/source): | Metric | old 5be0937d | new b7086621 | |---|---:|---:| | FPS | 3.00 | 4.50 | | frame | 335.15 ms | 219.91 ms | | `gpu_scene_total` | 100.13 ms | 38.40 ms | | `gpu_deferred` | 76.43 ms | 16.02 ms | | `gpu_volumetrics` | 213.00 ms | 159.81 ms | | `gpu_light_culling` | 14.40 ms | 13.08 ms | The range fix works on both vendors. The tablet is now dominated by volumetrics (~162 ms, ~74% of the frame), not deferred lighting or shadows. Follow-up #1089 covers the Adreno volumetric investigation and the tablet light-culling net-benefit check.
Author
Owner

Volumetric split and first mobile tier are in:

  • 7060c5bf adds gpu_volumetric_inject, gpu_volumetric_accumulate, gpu_volumetric_composite plus the existing aggregate.
  • 3233c0b5 adds VolumetricQuality::Mobile (128x80x64 at 2560x1600), uses it on Android in the all-in-one example, and switches light tiles from 16px to 8px.

Tablet baseline split before the tier: inject ~93 ms, accumulate ~45–59 ms, composite ~26 ms, total ~160–178 ms. The new tier should bring the tablet near the earlier V3 custom result (~34 ms volumetrics), with tile 8 reducing the culling pass from ~13 ms to ~7 ms.

Sync the copied all-in-one source before rebuilding, then recapture tablet and phone.

Volumetric split and first mobile tier are in: - `7060c5bf` adds `gpu_volumetric_inject`, `gpu_volumetric_accumulate`, `gpu_volumetric_composite` plus the existing aggregate. - `3233c0b5` adds `VolumetricQuality::Mobile` (128x80x64 at 2560x1600), uses it on Android in the all-in-one example, and switches light tiles from 16px to 8px. Tablet baseline split before the tier: inject ~93 ms, accumulate ~45–59 ms, composite ~26 ms, total ~160–178 ms. The new tier should bring the tablet near the earlier V3 custom result (~34 ms volumetrics), with tile 8 reducing the culling pass from ~13 ms to ~7 ms. Sync the copied all-in-one source before rebuilding, then recapture tablet and phone.
Author
Owner

Mobile tier verified: tablet 4.47 → 11.27 FPS (frame 224 → 88 ms), phone 19.94 → 30.41 FPS. Tablet volumetrics 164.08 → 34.71 ms. Composite is now the common volumetric bottleneck (21.1 ms tablet / 9.16 ms phone), so de1d9883 reduces the Mobile composite from 32 to 16 steps.

Remaining tablet split: composite, inject, accumulate; next capture will confirm the step reduction and check for banding.

Mobile tier verified: tablet 4.47 → 11.27 FPS (frame 224 → 88 ms), phone 19.94 → 30.41 FPS. Tablet volumetrics 164.08 → 34.71 ms. Composite is now the common volumetric bottleneck (21.1 ms tablet / 9.16 ms phone), so `de1d9883` reduces the Mobile composite from 32 to 16 steps. Remaining tablet split: composite, inject, accumulate; next capture will confirm the step reduction and check for banding.
Author
Owner

Mobile tier + 16-step composite verified at de1d9883:

Device Baseline before Mobile Final
Phone 20.19 FPS 35.76 FPS
Tablet 4.47 FPS 12.88 FPS

Tablet volumetrics 164.08 → 24.01 ms; phone 12.67 → 5.42 ms. The tablet non-volumetric floor is ~16.8 FPS / 59.3 ms, so remaining volumetric headroom is limited. Remaining tablet split: inject ~11.1 ms, composite ~10.4 ms, accumulate ~2.5 ms.

Further engine optimization is optional; visual range tuning is the next practical step.

Mobile tier + 16-step composite verified at `de1d9883`: | Device | Baseline before Mobile | Final | |---|---:|---:| | Phone | 20.19 FPS | **35.76 FPS** | | Tablet | 4.47 FPS | **12.88 FPS** | Tablet volumetrics 164.08 → 24.01 ms; phone 12.67 → 5.42 ms. The tablet non-volumetric floor is ~16.8 FPS / 59.3 ms, so remaining volumetric headroom is limited. Remaining tablet split: inject ~11.1 ms, composite ~10.4 ms, accumulate ~2.5 ms. Further engine optimization is optional; visual range tuning is the next practical step.
Author
Owner

Merged as 7d67a8cf via PR #1093.

Final state of the branch:

  • Light range is explicit (10-unit default, glTF range supported) with smooth falloff.
  • VolumetricQuality::Mobile: 48 depth slices, 8 composite steps, reduced X/Y grid.
  • Light-culling tiles are 8 px.
  • GPU timestamps split scene, volumetric inject/accumulate/composite, tonemap, and AA.

Measured final baseline (native resolution, full visuals):

Device FPS
Phone (Mali-G720, 1220×2582) ~35.8+ FPS
Tablet (Adreno 810, 2560×1600) 14.56 FPS

The tablet is now below 30 FPS because of the native 2560×1600 resolution and post chain, not the light-range/volumetric bug. Resolution scaling is tracked separately in #1083.

Closing this root issue; the remaining post-processing and native-resolution work belongs to the follow-up issues.

Merged as `7d67a8cf` via PR #1093. Final state of the branch: - Light range is explicit (10-unit default, glTF range supported) with smooth falloff. - `VolumetricQuality::Mobile`: 48 depth slices, 8 composite steps, reduced X/Y grid. - Light-culling tiles are 8 px. - GPU timestamps split scene, volumetric inject/accumulate/composite, tonemap, and AA. Measured final baseline (native resolution, full visuals): | Device | FPS | |---|---:| | Phone (Mali-G720, 1220×2582) | ~35.8+ FPS | | Tablet (Adreno 810, 2560×1600) | 14.56 FPS | The tablet is now below 30 FPS because of the native 2560×1600 resolution and post chain, not the light-range/volumetric bug. Resolution scaling is tracked separately in #1083. Closing this root issue; the remaining post-processing and native-resolution work belongs to the follow-up issues.
Sign in to join this conversation.
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
SakulFlee/Orbital#1073
No description provided.