Sky Force Reloaded case study
Sky Force Reloaded from mobile game developer Infinite Dreams is an action game that is set in a rich graphics environment. The game demands a lot from both the application processor and the GPU. Infinite Dreams first developed the game with OpenGL ES in Unity, and then started examining optimization options.
Choosing what to optimize
Sky Force Reloaded is a very rich game, displaying many objects at the same time. The team decided that the area likely to yield the best optimization would be fill rate.
Fill rate is the speed at which the GPU can draw frames every second. Gamers like to see 60 frames per second (FPS), but performance issues can make the FPS drop. Usually, you can eliminate fill rate problems by decreasing the resolution of the frame buffer. But Sky Force Reloaded had performance problems even at a low resolution and on high-end devices, and could not always maintain 60 FPS.
The team learned that the game was making as many as 1,000 draw calls per frame. To prepare data for the GPU for those draw calls, the OpenGL ES driver was keeping the application processor busy for long periods. Even on the high-end devices, this much work on the application processor was causing the device to slow down. In other words, every draw call has a computation overhead, so the large number of calls the game makes is computationally expensive.
With OpenGL ES, the team had two options to optimize the fill rate: minimize the number of draw calls, or modify the calls so that the game engine could batch them. However, both options can reduce the quality of the game. So the team decided to see what sort of optimization Vulkan can provide.
Testing OpenGL ES and Vulkan on Sky Force Reloaded
The team decided to compare the performance of the game using Vulkan and OpenGL ES. They created a benchmark from the slowest part of the game, where OpenGL ES could not deliver 60 FPS. Using a specific scene of the game as a benchmark meant that the team could compare both APIs directly.
Performance was measured by the total time, in seconds, that each API could provide 60 FPS. In the following graph, you can see that the Vulkan performance is a 15% improvement on the OpenGL ES performance:
The team decided to push the APIs a bit further. They added more objects to the benchmark scene, until even Vulkan was struggling to provide 60 FPS. With all the additional objects, the performance gap between the APIs grew. Vulkan was now 32% more efficient than OpenGL ES, as measured as total time each API could provide 60 FPS. The graph shows the FPS for each API as they rendered the benchmark scene:
The test clearly showed that when using Vulkan, the team could add more objects, animations, and particles without sacrificing their FPS. The game looked even richer, without requiring changes other than the API switch.
Comparing object quantities at 60 FPS
Next, the team checked how many objects Vulkan can render without negatively impacting the FPS. The team found that at a frame rate of 60 FPS, Vulkan can render six times more stars and twice as many bullets as OpenGL ES. Our side-by-side video demonstrates the difference, as shown in this screen capture:
Comparing power consumption
Sky Force Reloaded is a game that is GPU and processor intensive, leading some players to complain of battery drain. The team did not want to compromise on the console-like graphics, so they compared power consumption with Vulkan and OpenGL ES. Vulkan lowered power consumption by 10-12%, increasing play time for a given battery charge. You can see a side-by-side comparison on YouTube, as shown in this screen capture:
Case study results
By switching Sky Force Reloaded to Vulkan, the development team gained better graphics at a lower power consumption. Because they relied on Unity to interface with Vulkan, the switch did not require development work.