Unity Shader Learning Note 1

This article starts learning Unity Shader from scratch.

Start by creating a Unity Shader (Surface Shader):

Shader "Custom/NewSurfaceShader"
{
    Properties
    {
        _Color ("Color", Color) = (1,1,1,1)
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Glossiness ("Smoothness", Range(0,1)) = 0.5
        _Metallic ("Metallic", Range(0,1)) = 0.0
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        half _Glossiness;
        half _Metallic;
        fixed4 _Color;

        UNITY_INSTANCING_BUFFER_START(Props)
        UNITY_INSTANCING_BUFFER_END(Props)

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
            o.Albedo = c.rgb;
            o.Metallic = _Metallic;
            o.Smoothness = _Glossiness;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

This Unity Shader code defines a custom Surface Shader that is used to render surfaces with basic physical properties such as color, glossiness, and metallic feel. Let's explain each part in detail:

Shader Declaration#

Shader "Custom/NewSurfaceShader"
This line declares a new Shader and names it "Custom/NewSurfaceShader". This name can be found and applied to game objects in Unity's Material Editor.

Properties#

This section of code defines the parameters that the Shader receives from the outside, so that they can be modified in the Inspector panel.

To see the specific results, first create a new material, then select the Shader created earlier in the Shader of the material's Inspector panel. You can then see the properties defined in the Properties section of the Shader code:

Let's analyze the syntax of Properties:

_PropertyName ("Display Name", PropertyType) = DefaultValue

The corresponding declaration in the Shader code can be explained as follows:

Properties {
    _Color ("Color", Color) = (1,1,1,1) // Defines a color property with a default value of white.
    _MainTex ("Albedo (RGB)", 2D) = "white" {} // Defines a 2D texture property that uses a white texture by default.
    _Glossiness ("Smoothness", Range(0,1)) = 0.5 // Defines a float property between 0 and 1, representing the smoothness of the surface.
    _Metallic ("Metallic", Range(0,1)) = 0.0 // Defines a float property between 0 and 1, representing the metallic feel of the material.
}

SubShader#

The SubShader block defines the actual rendering logic. If a Shader contains multiple SubShaders, Unity will choose the most suitable one based on hardware and performance.

Tags { "RenderType"="Opaque" }: Specifies that this Shader is used for rendering opaque objects.
LOD 200: Sets the level of detail (LOD) for the Shader, which affects rendering performance and quality.

CGPROGRAM#

The code between CGPROGRAM and ENDCG is the actual Shader code, written in the Cg/HLSL language.

#pragma surface surf Standard fullforwardshadows

Declares the lighting model and shadow settings for this Shader.

In Unity's Shader code, #pragma directives are used to provide specific compilation instructions to the compiler.

#pragma target 3.0: Specifies Shader Model 3.0 to achieve better lighting effects.

sampler2D _MainTex; defines a 2D texture sampler. In the Shader, texture sampling is used to read pixel data from textures, typically storing basic diffuse maps.

In CG, a texture is generally a memory of 3 or 4 channels (depending on whether there is an alpha channel, each channel is 8 bits), and the sampler helps us automatically calculate the correspondence between each pixel and coordinate, as well as the offset.

The Input structure defines the input data structure. Specifically, Input defines uv_MainTex as a float2 type, representing the UV coordinates of the main texture.

half _Glossiness defines a half variable (a low-precision floating-point type that occupies less memory), which is used to control the smoothness of the material. Similarly, _Metallic is a variable that controls the metallic feel of the material. _Color is of type fixed4 (a low-precision quaternion), used to store the base color of the material.

The following two lines are instructions about GPU instancing support, which can be ignored for now.

The surf function is the core of the Shader. This function calculates the surface properties, such as glossiness and color, and is responsible for shading the material.

The surf Function#

In Unity's Surface Shader, the surf function is a core component that defines the visual properties of the material surface. This function processes the input and outputs the result to a specific data structure that describes how the surface interacts with light.

Execution process:
Input: The surf function takes an Input structure as a parameter, which contains all the necessary input data, such as UV coordinates, normals, etc., depending on the Shader definition. In your code example, the Input structure contains uv_MainTex, which is the UV coordinates of the main texture.

Multiple invocations: During the rendering process, Unity calls the surf function for each pixel or vertex. For each pixel, it uses the corresponding input data (such as texture coordinates and other available vertex data) to calculate the surface's output.

Output: The output is achieved by modifying the second parameter of the surf function, which is a writable SurfaceOutputStandard structure. This structure contains various properties that determine the final appearance of the pixel, such as albedo, metallic, smoothness, and alpha. These properties simulate the behavior of real-world materials based on their physical properties.

Effects on material appearance: The data output by the surf function is used by Unity's rendering engine to calculate the final pixel color, taking into account the lighting model and the lighting conditions in the scene. This way, the color of each pixel is dynamically calculated based on its specific surface characteristics and the lighting conditions in the scene.

The above is the entire code content of creating a new shader.