Post-processing is a great feature that instantly enhances the atmosphere of the game screen by applying bloom (luminous effects) and color grading. However, if this is used as is for development for mobile devices or standalone VR such as Meta Quest, it will easily exceed the limits of the GPU and cause a fatal processing slowdown. In this article, we will explain in an easy-to-understand manner how this high-load bug caused by the memory structure of mobile GPUs works, using the analogy of ``double work between photo development and makeup'', and present optimization settings that can dramatically improve FPS while maintaining a beautiful appearance.

1. Understanding with an analogy: The double work of photo development and makeup causes a blowout on the workbench

Why is post-processing so unusually heavy on mobile and VR devices? Let me explain this by comparing it to ``loading and unloading a huge piece of drawing paper at a photo lab.''

Imagine a chef or artist's workbench (the tile cache, which is the GPU's internal memory). Mobile graphics chips are good at quickly finishing drawings (such as drawing opaque objects) just on the workbench, although this workbench is very small. However, post-processing is an ``image processing makeup'' that extracts and processes the photographed photo (the pixel data of the entire screen).

When performing this make-up, the processing system (post-processing pass) ``brings a huge drawing paper (full screen buffer) from the warehouse (VRAM) and spreads it on the desk'' ``In order to apply blur to a part, another huge piece of tracing paper (intermediate texture) ``When finished, put it away in the warehouse and bring another huge piece of paper from the warehouse for the next effect (Bloom, etc.).'' The back-and-forth transportation of huge sheets of paper between the warehouse and the desk (memory loading and storing) is repeated dozens of times every frame.

For mobile GPUs, this "width of the passage connecting the warehouse and workbench (Memory Bandwidth)" is extremely narrow. As a result, just transporting a huge piece of drawing paper back and forth causes a complete traffic jam in the aisle (bandwidth blowout), and even though the GPU itself has extra computing power, it wastes time waiting for the paper to arrive (memory stall), causing the frame rate to drop into the abyss. This waste doubles or triples, especially in the latest smartphones with high screen resolutions, and VR (Meta Quest) environments that draw two giant pictures for each eye.

2. Solution A: Completely eliminate high-load effects and make Bloom ``Fast''

The most reliable solution is to completely disable in the inspector the effects that force ``huge paper back and forth'' that would ruin the narrow workbench of a mobile GPU, and to simplify the processing of the main effects.

Setting items to disable/adjust:

  1. Depth of Field: Completely disabled (highest priority)
    This process of sampling and blurring a wide area around pixels is a critical burden on mobile GPUs, requiring tens of thousands of additional memory binds. If it is absolutely necessary for UI previews, etc., perform alternative processing such as blurring the RenderTexture side of the background before drawing.
  2. Motion Blur / Chromatic Aberration: Disabled
    This function, which samples pixels while shifting them according to the movement of the screen, also has a very high load on memory and can cause high heat in real devices.
  3. Bloom (light emitting effect): Change the quality to "Fast"
    Bloom extracts the glowing parts of the screen, reduces the resolution to 1/2, 1/4, and 1/8, blurs them, and performs a process (pyramid blur) that adds and combines them again. By opening Bloom's settings in the inspector and switching the Quality to "Fast", you can reduce the number of reduction copies (passes) and reduce the burden on memory bandwidth by more than half.

3. Solution B: Apply a dynamic Render Scale

As the overall screen resolution increases, the number of pixels targeted for post-processing increases multiplicatively. For example, a smartphone with a 4K display has to process four times as many pixels per frame as Full HD. For this problem, an approach that dynamically lowers the render scale slightly from a C# script is very effective.

The script below is a control program that appropriately scales down the drawing resolution to avoid memory band blowout caused by post-processing only when executed on an actual mobile device. 

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class MobileResolutionOptimizer : MonoBehaviour
{\
    [Range(0.5f, 1.0f)]
    public float mobileRenderScale = 0.85f; // Render scale on actual mobile device

 void Start()
 {
 #if !UNITY_EDITOR && (UNITY_ANDROID || UNITY_IOS)
 ApplyOptimization();
 #endif
 }

 void ApplyOptimization()
 {
 // Get the URP Asset currently in use
 UniversalRenderPipelineAsset urpAsset = GraphicsSettings.currentRenderPipeline as UniversalRenderPipelineAsset;
 
 if (urpAsset != null)
 {
 // Set the render scale to 0.85 (reducing resolution by about 15%)
 // This reduces the total number of pixels to post-process by about 28%, dramatically lowering memory pressure.
 urpAsset.renderScale = mobileRenderScale;
 Debug.Log($"Mobile optimization applied: Render Scale set to {mobileRenderScale}");
 }
 }
}

This reduction in resolution is hardly perceptible to the player's naked eye as a degradation in image quality, as smartphone screens are very dense (high PPI). However, for the GPU, the number of pixels to be processed is reduced by approximately 30%, which creates a large margin in memory bandwidth and enables smooth 60FPS/90FPS operation without stuttering.