In HLSL, shaderA program that runs on the GPU. More info
See in Glossary models are a way of describing the capabilities of a GPU. You can tell Unity to compile shaders for GPUs with certain capabilities, either by specifying the shader model that the GPU must support, or by specifying individual features that the GPU must support.
For general information on shader models in HLSL, see the Microsoft documentation: Shader Models vs Shader Profiles .
To specify a shader model or GPU feature that your Shader object requires, you use pragma directives in your HLSL code. You can indicate the shader model by using the
#pragma target name directive, and you can indicate features using the
#pragma require feature … directive.
#pragma target 3.5 #pragma require integers 2darray instancing
For more information on pragma directives, see HLSL pragma directives.
By default, Unity compiles shaders into almost the lowest supported target (“2.5”); in between DirectX shader models 2.0 and 3.0. Some other compilation directives make the shader automatically be compiled into a higher target:
#pragma geometry) sets the compilation target to
#pragma domain) sets the compilation target to
Any shader not explicitly setting a function entry point through
#pragma for geometry, hull or domain shaders will downgrade internal shader capability requirements. This allows non-DX11 targets with broader run-time and feature differences to be more compatible with the existing shader content.
For example, Unity supports tessellation shaders on Metal graphics, but Metal doesn’t support geometry shaders. Using
#pragma target 5.0 is still valid, as long as you don’t use geometry shaders.
Here is the list of shader models supported, with roughly increasing set of capabilities (and in some cases higher platform/GPU requirements):
Note that all OpenGL-like platforms (including mobile) are treated as “capable of shader model 3.0”. WP8/WinRT platforms (DX11 feature level 9.x) are treated as only capable of shader model 2.5.
List of supported feature names for the
#pragma require directive:
interpolators10: At least 10 vertex-to-fragment interpolators (“varyings”) are available.
interpolators15: At least 15 vertex-to-fragment interpolators (“varyings”) are available.
interpolators32: At least 32 vertex-to-fragment interpolators (“varyings”) are available.
mrt4: Multiple Render Targets, at least 4.
mrt8: Multiple Render Targets, at least 8.
derivatives: PixelThe smallest unit in a computer image. Pixel size depends on your screen resolution. Pixel lighting is calculated at every screen pixel. More info
samplelod: Explicit texture LOD sampling (tex2Dlod / SampleLevel).
fragcoord: Pixel location (XY on screen, ZW depth in clip space) input in pixel shader.
integers: Integers are an actual data type, including bit/shift operations.
2darray: 2D texture arrays (Texture2DArray).
cubearray: CubemapA collection of six square textures that can represent the reflections in an environment or the skybox drawn behind your geometry. The six squares form the faces of an imaginary cube that surrounds an object; each face represents the view along the directions of the world axes (up, down, left, right, forward and back). More info
instancing: SV_InstanceID input system value.
geometry: DX10 geometry shaders.
compute: Compute shaders, structured buffers, atomic operations.
randomwrite: “random write” (UAV) textures.
tesshw: GPU support for hardware tessellation, but not necessarily tessellation shader stages (e.g. Metal supports tessellation, but not via shader stages).
tessellation: Tessellation hull/domain shader stages.
msaatex: Ability to access multi-sampled textures (Texture2DMS in HLSL).
sparsetex: Sparse textures with residency info (“Tier2” support in D3D terms; CheckAccessFullyMapped HLSL function). Note that currently this is only implemented on DX11/12.
framebufferfetch: Framebuffer fetch – ability to read input pixel color in the pixel shader.
#pragma target directives are shorthands for the requirements above, and they correspond to:
3.0: 2.5 + interpolators10 + samplelod + fragcoord
3.5: 3.0 + interpolators15 + mrt4 + integers + 2darray + instancing
4.0: 3.5 + geometry
5.0: 4.0 + compute + randomwrite + tesshw + tessellation
4.5: 3.5 + compute + randomwrite
4.6: 4.0 + cubearray + tesshw + tessellation
Note that in Direct3D terms shader model 4.0 also implies “mrt8”; and shader model 5.0 implies “interpolators32” and “cubearray”. However, these are not guaranteed to be available on many mobile platforms. So for backwards compatibility with existing shaders, writing #pragma target 4.0 does not automatically require 8 MRTs support; and writing #pragma target 5.0 does not require 32 interpolators nor cubemap arrays.