Oculus Quest and Go: Fixed Foveated Rendering

Oculus Go and Quest support Fixed Foveated Rendering (FFR). FFR enables the edges of the eye buffers to be rendered at a lower resolution than the center portion of the eye buffers. Note that, unlike some other forms of foveation technologies, FFR is not based on eye tracking. Instead, the high-resolution pixels are “fixed” in the center of the eye buffers.

The visual effect of using FFR is nearly imperceptible, but FFR performance benefits, including:

• Significantly improves GPU fill performance
• Reduces power consumption, and thereby reduces heat and increases battery life
• Enables applications to increase the resolution of eye textures, which improves the viewing experience, while maintaining performance and power consumption levels

There are some tradeoffs when using FFR:

• FFR is most useful for low contrast textures, including background images and large objects.
• FFR is less useful for high-contrast items, such as text and fine detailed images, and can cause noticeable degradation in the image quality.
• Complex fragment shaders benefit from FFR.

You can adjust the FFR level on a frame-by-frame basis in order to achieve the best tradeoff between performance and visual quality. In general, you should try to use FFR as much as possible, and set it to as high a level as possible, but you should test your content and look for any undesirable visual artifacts.

You can also use dynamic FFR to have the FFR level set automatically based on the GPU load and requirements of the application.

On This Page

• FFR in More Detail
• Dynamic Foveation
• Set the FFR Level

FFR in More Detail

The gains (or losses) provided by FFR typically depend of your application’s pixel shader costs. FFR can result in a 25% gain in performance with pixel-intensive applications. On the other hand, applications with very simple shaders, which are not bound on GPU fill, will likely not see a significant improvement from FFR. A highly ALU-bound application will benefit from this, as shown in the graph below that collects GPU % on a scene. Given a 16% GPU utilization coming from timewarp (and therefore not affected by FFR), this graph shows a 6.5% performance improvement from the low setting, 11.5% improvement from medium setting, and a 21% improvement from the high setting.

This demonstrates a best case scenario for using FFR. If you perform the same test on an application which has very simple pixel shaders, it is possible to actually have a net loss on the low setting, due to the fact that the fixed overhead of using FFR can be higher than the rendering savings on a relatively small number of few pixels. In fact, in this situation, you might experience a slight gain with the high setting, but it won’t be worth the image quality loss.

Unlike traditional 2D screens, VR devices require that the image displayed to the viewer be warped to match the curvature of the lenses in the headset. This distortion allows us to perceive a larger field of view than we would by simply looking at a raw display. The image below shows the effect of distortion, where a 2D plane (the horizontal line) is warped into a spherical shape:

Pixels that make up an eye texture are very unevenly represented due to the distortion. More pixels are required to create the post-distortion areas at the edge of the FOV than the center of the FOV, which results in a higher pixel density at the edge of the FOV than in the middle. This is highly counterproductive since users generally look toward the center of the screen. On top of that, lenses blur the edge of the field of view, so even though many pixels have been rendered in that part of the eye texture, the sharpness of the image is lost. The GPU spends a lot of time rendering pixels at the edge of the FOV that can’t be clearly seen. This is very inefficient.

Fixed Foveated Rendering reclaims some of the wasted GPU processing resources by lowering the resolution of the output image during its computation. This is implemented by controlling the resolution of individual render tiles on the GPU. Oculus Go and Quest use a tiled renderer. FFR works by controlling the resolution of individual tiles, and ensuring that the tiles that fall on the edges of the eye buffer are lower resolution than the center. This reduces the number of pixels that the GPU needs to fill without perceptibly lowering the quality of the post-distortion image and as a result translates to a very significant improvement in GPU performance for applications that render a large number of pixels.

FFR Render Examples

The screenshots below show the tile resolution multiplier map for a 1024x1024 eye buffer. The colors represent the following resolution levels in the example images that follow to demonstrate the FFR settings:

• White = Full resolution: This is the center of the FOV. Every pixel of the texture is computed independently by the GPU.
• Red = 1/2 resolution: Only half of the pixels are calculated by the GPU. The missing pixels are interpolated from the calculated pixels at resolve time, when the GPU stores the result of its computation in general memory.
• Green = 1/4 resolution: Only one quarter of the pixels are calculated by the GPU. The missing pixels are interpolated from the calculated pixels at resolve time, when the GPU stores the result of its computation in general memory.
• Blue = 1/8 resolution: Only one eighth of the pixels are calculated by the GPU. The missing pixels are interpolated from the calculated pixels at resolve time, when the GPU stores the result of its computation in general memory.
• Pink = 1/16 resolution: Only one sixteenth of the pixels are calculated by the GPU. The missing pixels are interpolated from the calculated pixels at resolve time, when the GPU stores the result of its computation in general memory.

HighTop	High
Medium	Low

Dynamic Foveation

The foveation level can also be configured to be automatically adjusted based on the GPU utilization by turning on dynamic foveation. When dynamic foveation is enabled, the foveation level will be adjusted automatically with the specified foveation level as the maximum. The system goes up to the chosen foveation level, but never above, based on GPU utilization and the requirements of the application.

Set the FFR Level

There are multiple ways to set the FFR level and turn on dynamic foveation.

Project Settings

You can set the FFR level in your Unreal project settings. To access these settings:

• In Unreal go to Edit > Project Settings
• Display the Oculus settings by clicking OculusVR under Plugins, and on the On the Plugins - OculusVR page, find Mobile
• Use the FFRlevel to set the desired foveation level
• Check FFRDynamic to turn on dynamic FFR (it will be unchecked by default) The following image shows and example of the project settings:

API to Set FFR

You can set the level of FFR to any the following indexes using the following method:

void UOculusFunctionLibrary::SetFixedFoveatedRenderingLevel(EFixedFoveatedRenderingLevel level, bool isDynamic)

Where:

• isDynamic is true to indicate dynamic FFR is on, or false to indicate dynamic FFR is off

• level is one of the following values:

  • EFixedFoveatedRenderingLevel_Off (index = 0): No reduction of resolution. (Default)
  • EFixedFoveatedRenderingLevel_LMSLow (index = 1): The lowest level of resolution reduction.
  • EFixedFoveatedRenderingLevel_LMSMedium (index = 2): The medium level of resolution reduction.
  • EFixedFoveatedRenderingLevel_LMSHigh (index = 3): High level of resolution reduction.
  • EFixedFoveatedRenderingLevel_LMSHighTop (index = 4) The highest level of resolution reduction. Provides more detail near the bottom of the view and more foveation near the top.

Blueprints to Get and Set the FFR Level

The Blueprints to get and set FFR are located under the Unreal Blueprints folder path Oculus Library.

• Use the Get Fixed Foveated Rendering Level blueprint to get the current FFR level setting. The following image shows an example:

  

• Use the Set Fixed Foveated Rendering Level blueprint to set the FFR level to one of the five possible values, and to select whether FFR is dynamic. The following image shows an example:

  

  Additional Resources

• Optimizing Oculus Go for Performance (blog)
• Fixed Foveated Rendering in the native documentation