This page contains information on the following techniques:
For a general overview of conditionals in shader code and when to use which technique, see Conditionals in shader code.
When a shader program includes conditionals that are evaluated at compile time, it uses static branching. The compiler excludes the code from the unused branch, so it does not appear in the compiled shader program.
Internally, Unity uses static branching when it creates shader variants. Static branching on its own does not have any of the performance disadvantages of shader variants.
The main advantage of static branching is that it has no negative impact on runtime performance. The main disadvantage of static branching is that you can only use it at compile time.
Static branching means that the compiler excludes unneeded code from the shader program. It results in small, specialized shader programs that contain only the necessary code. There is no runtime performance cost to static branching; in fact, the smaller programs are likely to result in quicker load times and lower runtime memory usage.
To use static branching, the conditions must be constant at compile time. This means that you can’t use it to execute code for different conditions at runtime.
You can use static branching in your shaders in the following ways:
#endif preprocessor directives, or
#ifndef preprocessor directives to create static branches.
if statements can also be used for dynamic branches, the compiler detects the compile-time constant value and creates a static branch instead.
Note: Static branching is available only in hand-coded shaders. You cannot create static branches in Shader Graph.
When a shader program includes conditionals that are evaluated at runtime, it uses dynamic branching.
There are two types of dynamic branching: dynamic branching based on uniform variables, and dynamic branching based on any other runtime value. Uniform-based branching is usually more efficient, because the uniform value is constant for the whole draw call.
You can use shader keywords for dynamic branching. This allows you to use C# scriptsA piece of code that allows you to create your own Components, trigger game events, modify Component properties over time and respond to user input in any way you like. More info
See in Glossary and the Material InspectorA Unity window that displays information about the currently selected GameObject, asset or project settings, allowing you to inspect and edit the values. More info
See in Glossary to configure runtime branching behavior for your shaders. This results is uniform-based branching; when you do this, Unity compiles the shader keywords as uniforms.
The main advantage of dynamic branching is that it allows you to use conditionals at runtime without increasing the number of shader variants in your project. The main disadvantage of dynamic branching is that it impacts GPU performance.
The GPU performance impact varies by hardware, and by shader code. The reasons are:
In general, if your code branches on uniform values and both branches have roughly similar workloads, then the impact on GPU performance is likely to be small. However, you should always profile your application and consider the advantages and disadvantages case-by-case.
Note: Dynamic branching can also lead to large shader programs, because the code for all conditions is compiled into the same shader program. However, the effect of these larger files on load times and memory usage is usually less significant than the impact of shader variants.
For information about other ways of using conditionals in shaders, and how to decide which technique is right for your use case, see Conditionals in shaders.
You can use dynamic branching in your shaders in the following ways: