[TGDF 2020] Mobile Graphics Best Practices for Artist

Mobile Graphics
Best Practices for
Artists
TGDF 2020
Owen Wu (owen.wu@arm.com)
Developer Relations Engineer

2 © 2020 Arm Limited
• Introduction
• Texturing
• Geometry
• Shaders
• Frame Rendering
• Resources
Agenda

© 2020 Arm Limited (or its affiliates)
Texturing

Texture Filtering - Trilinear
• Trilinear - Like Bilinear but with added
blur between mipmap level
• Don’t use trilinear with no mipmap
• This filtering will remove noticeable
change between mipmap by adding
smooth transition
• Trilinear filtering is still expensive on
mobile
• Use it with caution

Texture Filtering - Anisotropic
• Anisotropic - Make textures look better
when viewed from different angle, which
is good for ground level textures
• Higher anisotropic level cost higher

• Use bilinear for balance between performance and visual quality
• Trilinear will cost more memory bandwidth than bilinear and needs to be used
selectively
• Bilinear + 2x Anisotropic most of the time will look and perform better than Trilinear +
1x Anisotropic, so this combination can be better solution rather than using Trilinear
• Keep the anisotropic level low
• Using a level higher than 2 should be done very selectively for critical game assets
• This is because higher anisotropic level will cost a lot more bandwidth and will affect device battery life
Texture Filtering

Always Use Mipmap If Camera Is Not Still
• Using mipmapping will improve GPU
performance
• Less cache miss
• Mipmapping also reduce texture aliasing
and improve final image quality
• Don’t use it on 2D objects

Texture Color Space
• Use linear color space rendering if using dynamic
lighting
• Check sRGB in texture inspector window
• Textures that are not processed as color should
NOT be used in sRGB color space (such as metallic,
roughness, normal map, etc)
• Current hardware supports sRGB format and
hardware will do Gamma correction automatically
for free

Texture Compression
• ASTC may get better quality
with same memory size as
ETC
• Or same quality with less
memory size than ETC
• ASTC takes longer to
encode compared to ETC
and might make the game
packaging process take
longer time. Due to this, it is
better to use it on final
packaging of the game
• ASTC allows more control in
terms of quality by allowing
to set block size. There are
no single best default in
block size, but generally
setting it to 5x5 or 6x6 is
good default

Texture Channel Packing
• Use texture channels to pack multiple
textures into one
• Commonly used to pack roughness, or
smoothness, and metallic into one
texture
• Can be applied for any texture mask
• Make good use of alpha channel

Geometry

Avoid Rendering Small Triangles
• The bandwidth and processing cost of a
vertex is typically orders of magnitude higher
than the cost of processing a fragment
• Make sure that you get many pixels worth of
fragment work for each primitive
• Make sure each model which create at least
10-20 fragments per primitive
• Use dynamic mesh level-of-detail, using
simpler meshes when objects are further
away from the camera

• More expensive for the GPU to process when compared with normal triangles
• GPUs process pixels in quad blocks
• Long thin triangle edges will waste more GPU power to rasterize
• Adjacent long thin triangles will waste doubly
Avoid Rendering Small Triangles

• Reuse as many vertices as possible
• Transformed vertex data can reused to save computation power
• Avoid duplicating vertices unless it’s necessary
Avoid Duplicating Vertices
V0
V1
V2
V3
V4
V0
V1
V2
V3
V5
V4 V7
V6
V8
T1 : (V0, V1, V2)
T2 : (V1, V3, V2)
T3 : (V2, V3, V4)
T1 : (V0, V1, V2)
T2 : (V3, V4, V5)
T3 : (V6, V7, V8)
GOOD BAD

Shaders

• Use mediump and highp keywords
• Full FP32 of vertex attributes is unnecessary for many uses of attribute data
• Keep the data at the minimum precision needed to produce an acceptable final output
• Use FP32 for computing vertex positions only
• Use the lowest possible precision for other attributes
• Don’t always use FP32 for everything
• Don’t upload FP32 data into a buffer and then read it as a mediump attribute
Shader Floating-point Precision

• Many fragments are occluded by other fragments
• Running fragment shader of occluded fragment is wasting GPU
power
• Render opaque object from front to back
• Occluded fragment will be rejected before shading
• Fragment writing out depth/stencil will go Late-Z path which rejects
occluded fragment after fragment shader
• Fragment using discard or Alpha-to-coverage will be forced to do
Late-Z and may stall the pipeline
Take Advantage of Early-Z
Early Frag
Op
Fragment
Shader
Late Frag Op

Avoid Heavy Overdraw
• Overdraw means one pixel has been
rendered more than once
• Alpha blending overdraw is expensive
on mobile
• Use Unity built-in display feature to
check the amount of overdraw
• Brighter area means more overdraw
• Make good arrangement of layer,
sorting layer, render queue and camera
setting to avoid overdraw

• Separate transparent mesh from opaque mesh
• Use polygon mesh instead of quad for transparent texture
• Both ways can reduce the amount of transparent fragments and improve performance
Reduce the Amount of Alpha Blending/Tested Fragments

• Dynamic branching in shader is not as expensive as most developers think, but…
• Both sides of branch will be executed and pick one if the branching area is too small
• Shader compiler will optimize it automatically
• Use dynamic branching when it can skip enough computation
• Check out this link for more details
• https://bit.ly/315P234
Dynamic Branching

Frame Rendering

• Render state switch is very expensive operation
• Rendering as many primitives as possible in one draw call
• Don’t just check number of draw calls or batches
• Number of render state switch is also an important index
• Using Tris/SetPass (i.e. 95.2K/34) is more accurate
• Batch as many draw call as possible
• Static batch
• GPU Instancing
• Dynamic batch
Reduce Render State Switch

Reduce Frame Buffer Switch
• Bind each frame buffer object only once
• Making all required draw calls before
switching to the next
• Avoid unnecessary context switch
• Use Unity frame debugger to check
• Use Arm Mobile Studio to do API level
check

• Before rendering, GPU will read frame buffer into tile memory
from external memory
• Minimizing start of tile loads
• Can cheaply initialize the tile memory to a clear color value
• Ensure that you clear or invalidate all of your attachments at the
start of each render pass
• Use Arm Mobile Studio to do API level check
Clear Frame Buffer Before Rendering
Didn’t clear before
switching render
target.
Bad for performance

• After rendering, GPU will write result to external
memory from tile memory
• Minimizing end of tile stores
• Avoid writing back to external memory whenever is
possible
• Disable writing to depth/stencil buffer if depth/stencil
value is not used
• Use Arm Mobile Studio to do API level check
Reduce Frame Buffer Write

Resources

©2020ArmLimited
Resources
• Arm Guide for Unity Developers (https://developer.arm.com/solutions/graphics-and-
gaming/gaming-engine/unity/arm-guide-for-unity-developers)
• 美術師在移動遊戲開發中的最佳實踐
(https://blogs.unity3d.com/cn/2020/04/07/artists-best-practices-for-mobile-game-
development/)

[TGDF 2020] Mobile Graphics Best Practices for Artist

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to [TGDF 2020] Mobile Graphics Best Practices for Artist

Similar to [TGDF 2020] Mobile Graphics Best Practices for Artist (20)

More from Owen Wu

More from Owen Wu (6)

Recently uploaded

Recently uploaded (7)

[TGDF 2020] Mobile Graphics Best Practices for Artist