Nixyri/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-02-16 07:40:36 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Updated tutorial_3d_performance (markdown)

reduz 2014-11-30 07:33:39 -08:00
parent cd3543a418
commit 613f512770
1 changed files with 2 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tutorial_3d_performance.md

@ -40,9 +40,9 @@ Nowadays, all this is handled inside the GPU, so the performance is extremely hi
On mobile devices, the story is different. PC and Console GPUs are brute-force monsters that can pull as much electricity as they need from the power grid. Mobile GPUs are limited to a tiny battery, so they need to be a lot more power efficient.
To be more efficient, mobile GPUs attempt to avoid _overdraw_. This means, the same pixel on the screen being rendered. Imagine a town with several buildings, GPUs don't really know what is visible and what is hidden until they draw it. A house might be drawn and then another house in front of it. PC GPUs normally don't care much about this and just throw more pixel processors to the hardware to increase performance (but this also increases power consumption).
To be more efficient, mobile GPUs attempt to avoid _overdraw_. This means, the same pixel on the screen being rendered (as in, with lighting calculation, etc) more than once. Imagine a town with several buildings, GPUs don't really know what is visible and what is hidden until they draw it. A house might be drawn and then another house in front of it (rendering happened twice for the same pixel!). PC GPUs normally don't care much about this and just throw more pixel processors to the hardware to increase performance (but this also increases power consumption).
On mobile, drawing more power is not an option, so a technique called "Tile Based Rendering" is used (every mobile hardware uses a variant of it), which divide the screen into a grid. Each cell keps the list of triangles drawn to it and sorts them by depth to minimize _overdraw_. This technique improves performance and reduces power consumption, but takes a toll on vertex performance. As a result, less vertices and triangles can be processed for drawing.
On mobile, pulling more power is not an option, so a technique called "Tile Based Rendering" is used (almost every mobile hardware uses a variant of it), which divide the screen into a grid. Each cell keps the list of triangles drawn to it and sorts them by depth to minimize _overdraw_. This technique improves performance and reduces power consumption, but takes a toll on vertex performance. As a result, less vertices and triangles can be processed for drawing.
Generally, this is not so bad, but there is a corner case on mobile that must be avoided, which is to have small objects with a lot of geometry within a small portion of the screen. This forces mobile GPUs to put a lot of strain on a single screen cell, considerably decreasing performance (as all the other cells must wait for it to complete in order to display the frame).