Use built-in shader functions in the Built-In Render Pipeline

Unity has a number of built-in utility functions in UnityCG.cginc designed to make writing shadersA program that runs on the GPU. More info
See in Glossary simpler and easier.

Transform positions

Transform other values

Forward rendering helper functions

These functions are only useful when using forward renderingA rendering path that renders each object in one or more passes, depending on lights that affect the object. Lights themselves are also treated differently by Forward Rendering, depending on their settings and intensity. More info
See in Glossary (ForwardBase or ForwardAdd pass types).

Screen-space helper functions

The following functions are helpers to compute coordinates used for sampling screen-space textures. They return float4 where the final coordinate to sample texture with can be computed via perspective division (for example xy/w).

The functions also take care of platform differences in render textureA special type of Texture that is created and updated at runtime. To use them, first create a new Render Texture and designate one of your Cameras to render into it. Then you can use the Render Texture in a Material just like a regular Texture. More info
See in Glossary coordinates.

Vertex-lit helper functions

These functions are only useful when using per-vertex lit shaders (“Vertex” pass type).

Shadow mapping macros

Declaring and sampling shadow maps can be very different depending on the platform. Unity has several macros to help with this:

The format of tex must be RenderTextureFormat.Shadowmap.

NOTE: Not all graphics cards support shadowmaps. Use SystemInfo.SupportsRenderTextureFormat to check for support.

Depth Texture helper macros

Most of the time, Depth Texture are used to render Depth from the Camera. The UnityCG.cginc include file contains some macros to deal with the above complexity in this case:

• COMPUTE_EYEDEPTH(i): computes eye space depth of the vertex and outputs it in o. Use it in a vertex program when not rendering into a depth texture.
• DECODE_EYEDEPTH(i)/LinearEyeDepth(i): given high precision value from depth texture i, returns corresponding eye space depth.
• Linear01Depth(i): given high precision value from depth texture i, returns corresponding linear depth in range between 0 and 1.
• UNITY_TRANSFER_DEPTH(o): Deprecated. Computes the eye space depth of the vertex and outputs it in o (which must be a float2). On platforms with native depth textures this macro does nothing, because the Z buffer value is rendered implicitly.
• UNITY_OUTPUT_DEPTH(i): Deprecated. Returns eye space depth from i (which must be a float2). On platforms with native depth textures this macro always returns zero, because the Z buffer value is rendered implicitly.

Note: On DX11/12 and Metal, the Z buffer range is 1–0 and UNITY_REVERSED_Z is defined. On other platforms, the range is 0–1.

For example, this shader would render depth of its GameObjectsThe fundamental object in Unity scenes, which can represent characters, props, scenery, cameras, waypoints, and more. A GameObject’s functionality is defined by the Components attached to it. More info
See in Glossary:

Shader "Render Depth" {
    SubShader {
        Tags { "RenderType"="Opaque" }
        Pass {
            CGPROGRAM

            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct v2f {
                float4 pos : SV_POSITION;
                float2 depth : TEXCOORD0;
            };

            v2f vert (appdata_base v) {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                UNITY_TRANSFER_DEPTH(o.depth);
                return o;
            }

            half4 frag(v2f i) : SV_Target {
                UNITY_OUTPUT_DEPTH(i.depth);
            }
            ENDCG
        }
    }
}