Shader "<name>"
{
    Properties // <optional: Material properties>
    {
        <Material property declaration>
        [optional: attribute] name("display text in Inspector", type name) = default value
        [Gamma] _ExampleName ("Integer display name", Integer) = 1
        [HDR] _ExampleName ("Float with range", Range(0.0, 1.0)) = 0.5
        [MainTexture] _ExampleName ("Texture3D", 3D) = "" {}
        [MainColor] _ExampleName("Example color", Color) = (.25, .5, .5, 1)
        [Normal] _ExampleName ("Example vector", Vector) = (.25, .5, .5, 1)
        ...
    } //--- end Properties

    SubShader // <One or more SubShader definitions>
    {
        <optional: PackageRequirements> // nó phải đứng trước tất cả các khai báo khác bên trong SubShader hoặc Pass nếu có.
        PackageRequirements{ [requirement definition]}

        <optional: LOD> // Assign a LOD (level of detail)
        LOD [value]
        LOD 200

        <optional: tags> // Assign key-value pairs of data to the SubShader, using the Tags block.
        Tags { “[name1]” = “[value1]” “[name2]” = “[value2]”}
        Tags { "RenderPipeline" = "UniversalRenderPipeline" }

        <optional: commands> // Add GPU instructions or shader code to the SubShader, using ShaderLab commands.

        <One or more Pass definitions> // Define one or more Passes, using the Pass block.
        Pass
        {
            <optional: PackageRequirements> // nó phải đứng trước tất cả các khai báo khác bên trong SubShader hoặc Pass nếu có.
            PackageRequirements{ [requirement definition]}

            <optional: name> // Assign a name to the Pass, using a Name block
            Name "<name>"
            Name "ExamplePassName"

            <optional: tags> // Assign key-value pairs of data to the Pass, using a Tags block.
            Tags {"<name1>" = "<value1>" "<name2>" = "<value2>"} // “LightMode” = “[value]”
            Tags { "ExampleTagKey" = "ExampleTagValue" }
            Tags { "LightMode" = "Always" }
            Tags { "LightMode" = "ForwardBase" "PassFlags" = "OnlyDirectional" }

            <optional: commands> // Perform operations using ShaderLab commands.

            <optional: shader code> // Add shader code to the Pass, using a shader code block.
            HLSLPROGRAM
                // [source code for shader programs, written in HLSL]
            ENDHLSL
            CGPROGRAM
                // [source code for shader programs, written in HLSL]
            ENDCG
            HLSLINCLUDE
                // [HLSL code that you want to share]
            ENDHLSL
            CGINCLUDE
                // [HLSL code that you want to share]
            ENDCG
        } //--- end Pass
    } //--- end SubShader

    // <optional: custom editor> // Sử dụng trình chỉnh sửa tùy chỉnh để hiển thị các loại dữ liệu mà Unity không thể hiển thị bằng Trình kiểm tra tài liệu mặc định của nó hoặc để xác định các điều khiển tùy chỉnh hoặc xác thực dữ liệu.
    CustomEditor “[custom editor class name]” // Unity sử dụng trình chỉnh sửa tùy chỉnh được xác định trong lớp được đặt tên, trừ khi điều này bị ghi đè bởi khối CustomEditorForRenderPipeline.
    CustomEditorForRenderPipeline “[custom editor class name]” “[render pipeline asset class name]” // Khi Nội dung đường ống kết xuất đang hoạt động là loại được đặt tên, Unity sử dụng trình chỉnh sửa tùy chỉnh được xác định trong lớp được đặt tên.

    // <optional: fallback>
    Fallback "<name>"
    Fallback "ExampleOtherShader"
    Fallback Off
} //--- end Shader

// Ví dụ: gán mầu trắng (White) cho Albedo
Shader "Example/Diffuse Simple" {
    SubShader {
      // Opaque: Là mặc định và phù hợp với các vật thể rắn thông thường không có vùng trong suốt.
      Tags { "RenderType" = "Opaque" }

      CGPROGRAM
      #pragma surface surf Lambert // To specifies that the surface function for this shader is "surf" and that a "Lambertian lighting model" should be used.
      struct Input {
          float4 color : COLOR;
      };

      // Surface Function: phải được đặt bên trong khối SubShader chứ không phải bên trong Pass
      // Ví vụ ở hàm này không sử dụng bất kỳ dữ liệu nào từ mô hình 3D gốc
      // mặc dù vậy, Cg/HLSL yêu cầu phải xác định cấu trúc đầu vào.
      void surf(Input IN, inout SurfaceOutput o) {
          o.Albedo = 1; // 1 = (1,1,1,1) = white
      }
      ENDCG

    }
    Fallback "Diffuse"
}

// Ví dụ: tạo hiệu ứng (chỉ định màu White cho Albedo) phụ thuộc vào khoảng cách từ một điểm cụ thể.
Shader "Example/Diffuse Distance" {
    Properties {
        _MainTex ("Texture", 2D) = "white" {} // gán một Texture để sử dụng
        _Center ("Center", Vector) = (0,0,0,0) // chọn 1 điểm điểm để so sánh
        _Radius ("Radius", Float) = 0.5 // xác định khoảng cách, phạm vi, bán kính từ Center
    }
    SubShader {
        Tags { "RenderType" = "Opaque" } // Rendering Mode: Opaque, Cutout, Transparent, Fade
        CGPROGRAM
        #pragma surface surf Lambert // Lighting Model
        struct Input { // Input Structure
            float2 uv_MainTex;
            float3 worldPos;
        };

        // lấy mẫ sampler texture, vector3, float từ Properties
        sampler2D _MainTex;
        float3 _Center;
        float _Radius;

        void surf (Input IN, inout SurfaceOutput o) { // Surface function
            float d = distance(_Center, IN.worldPos); // tính khoảng cách Center-Vertex
            float dN = 1 - saturate(d / _Radius); // clamps giá trị 'd' trong khoảng 0-1
            
            if (dN > 0.25 && dN < 0.3) // nếu 'dN' nằm trong một khoảng nào đó thì sẽ có màu WHITE
                o.Albedo = half3(1,1,1); // WHITE color
            else
                o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb; // nếu không thì lấy màu Texture
        }

        ENDCG
    } 
    Fallback "Diffuse"
}

struct SurfaceOutput
{
    fixed3 Albedo;  // diffuse color (màu khuếch tán)
    fixed3 Normal;  // tangent space normal, if written (không gian tiếp tuyến chuẩn tắc, nếu viết)
    fixed3 Emission;
    half Specular;  // specular power in 0..1 range (sức mạnh)
    fixed Gloss;    // specular intensity (cường độ)
    fixed Alpha;    // alpha for transparencies (alpha cho độ trong suốt)
};

// Ví dụ: normal extrusion - đỉnh mới sẽ bị dịch chuyển một khoảng 'amount' so với đỉnh trước đó.
 Shader "Example/Normal Extrusion" {
    Properties {
      _MainTex ("Texture", 2D) = "white" {} // lấy Texture từ Inspector
      _Amount ("Extrusion Amount", Range(-0.0001,0.0001)) = 0 // cài đặt amount 
    }
    SubShader {
      Tags { "RenderType" = "Opaque" }
      CGPROGRAM
      #pragma surface surf Lambert vertex:vert // chỉ thị Surface function & Vertex Function
      struct Input {
          float2 uv_MainTex;
      };
      float _Amount; // lấy mẫu
      void vert (inout appdata_full v) { // Vertex Function
          v.vertex.xyz += v.normal * _Amount; // mở rộng các đỉnh theo hướng pháp tuyến
      }
      sampler2D _MainTex; // lấy mẫu
      void surf (Input IN, inout SurfaceOutput o) { // Surface function
          o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb; // màu từ Texture
      }
      ENDCG
    } 
    Fallback "Diffuse"
}

// Ví dụ: tạo hiệu ứng Snow-Tuyết rơi trên các bề mặt đứng
Shader "Example/SnowShader" {
    Properties {
       _MainColor ("Main Color", Color) = (1.0,1.0,1.0,1.0)
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _Bump ("Bump", 2D) = "bump" {}
        _Snow ("Level of snow", Range(-1, 1)) = 1
        _SnowColor ("Color of snow", Color) = (1.0,1.0,1.0,1.0)
        _SnowDirection ("Direction of snow", Vector) = (0,1,0)
        _SnowDepth ("Depth of snow", Range(0,0.0001)) = 0
    }
    SubShader {
        Tags { "RenderType"="Opaque" }
        LOD 200 // mức độ chi tiết
 
        CGPROGRAM
        #pragma surface surf Lambert vertex:vert
 
        // lấy mẫu
        sampler2D _MainTex;
        sampler2D _Bump;
        float _Snow;
        float4 _SnowColor;
        float4 _MainColor;
        float4 _SnowDirection;
        float _SnowDepth;
 
        struct Input {
            float2 uv_MainTex;
            float2 uv_Bump;
            float3 worldNormal;
            INTERNAL_DATA
        };
 
        //--- NOTE ---
        // Các hàm có sử dụng tính toán tốn kém, nên code bên dưới chỉ tham khảo, cân nhắc việc sử dụng trong thực tế để không ảnh hưởng hiệu suất!
        // -----------
        void vert (inout appdata_full v)
        {
            // Convert _SnowDirection from world space to object space
            float4 sn = mul(_SnowDirection, _World2Object);
            if(dot(v.normal, sn.xyz) >= _Snow)
                v.vertex.xyz += (sn.xyz + v.normal) * _SnowDepth * _Snow;         
        }
 
        void surf (Input IN, inout SurfaceOutput o)
        {
            half4 c = tex2D (_MainTex, IN.uv_MainTex);
            o.Normal = UnpackNormal (tex2D (_Bump, IN.uv_Bump));
            if(dot(WorldNormalVector(IN, o.Normal), _SnowDirection.xyz)>=_Snow)
                o.Albedo = _SnowColor.rgb;
            else
                o.Albedo = c.rgb * _MainColor;
            o.Alpha = 1;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

Shader "Example/SimpleLambert" {
    Properties {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader {
        Tags { "RenderType" = "Opaque" }
        CGPROGRAM
        #pragma surface surf SimpleLambert // chỉ thị sử dụng 'SimpleLambert' buộc shader tìm kiếm một hàm 'LightingSimpleLambert'

        struct Input {
            float2 uv_MainTex;
        };

        sampler2D _MainTex;
        void surf (Input IN, inout SurfaceOutput o) {
            o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb;
        }

        // Hiểu cách hoạt động của mô hình chiếu sáng tiêu chuẩn là một bước thiết yếu nếu chúng ta muốn thay đổi nó. Trên thực tế, nhiều kỹ thuật tạo bóng thay thế vẫn sử dụng mô hình Lambertian làm bước đầu tiên.
        half4 LightingSimpleLambert (SurfaceOutput s, half3 lightDir, half atten) {
            half NdotL = dot (s.Normal, lightDir); // NdotL biểu thị hệ số cường độ, được nhân với màu của ánh sáng.
            half4 c;
            c.rgb = s.Albedo * _LightColor0.rgb * (NdotL * atten * 2); // 'atten' được dùng để điều chỉnh cường độ ánh sáng. Lý do tại sao nó được nhân với 2 là… một thủ thuật ban đầu được Unity3D sử dụng để mô phỏng một số hiệu ứng nhất định. Điều này cuối cùng đã được khắc phục trong Unity5 (hiện tại không cần *2)
            c.a = s.Alpha;
            return c;
        }

        ENDCG
    } 
    Fallback "Diffuse"
}

// Ví dụ: shading theo phong cách vẽ tay, vẽ màu
Shader "Example/Toon Shading" {
    Properties {
        _MainTex ("Texture", 2D) = "white" {} // Texture chính
        _RampTex ("Ramp", 2D) = "white" {} // sử dụng họa tiết bổ sung
    }
    SubShader {
        Tags { "RenderType" = "Opaque" }
        CGPROGRAM
        #pragma surface surf Toon // chỉ thị 'Toon' để sử dụng 'LightingToon'

        struct Input {
            float2 uv_MainTex;
        };
        sampler2D _MainTex;
        void surf (Input IN, inout SurfaceOutput o) {
            o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb; // sử dụng Texture chính
        }

        sampler2D _RampTex;
        fixed4 LightingToon (SurfaceOutput s, fixed3 lightDir, fixed atten)
        {
            half NdotL = dot(s.Normal, lightDir); 
            NdotL = tex2D(_RampTex, fixed2(NdotL, 0.5));

            fixed4 c;
            c.rgb = s.Albedo * _LightColor0.rgb * NdotL * atten * 2;
            c.a = s.Alpha;

            return c;
        }

        ENDCG
    } 
    Fallback "Diffuse"
}

// Ví dụ: Vertex and fragment shaders
Shader "Custom/SolidColor" {
    SubShader {
        Pass {
            CGPROGRAM

            // chỉ định hàm nào sẽ được sử dụng để tính toán đỉnh và đoạn.
            #pragma vertex vert             
            #pragma fragment frag

            struct vertInput { // khởi tạo vertInput
                float4 pos : POSITION; // binding semantic (ngữ nghĩa ràng buộc): khởi tạo vị trí với các vị trí đỉnh.
            };  

            struct vertOutput { // khởi tạo vertOutput
                float4 pos : SV_POSITION; // binding semantic (ngữ nghĩa ràng buộc): khởi tạo vị trí màn hình của một đỉnh
            };

            vertOutput vert(vertInput input) {
                vertOutput o;
                o.pos = mul(UNITY_MATRIX_MVP, input.pos); // Đỉnh nhận được là vị trí của một đỉnh trong tọa độ thế giới, điểm này phải được chuyển đổi thành tọa độ màn hình
                return o; // UNITY_MATRIX_MVP khi kết hợp với vị trí của một đỉnh, nó sẽ trả về vị trí của nó trên màn hình.
            }

            half4 frag(vertOutput output) : COLOR {
                return half4(1.0, 0.0, 0.0, 1.0); 
            }
            ENDCG
        }
    }
}

Shader "Custom/GrabShader" 
{
    SubShader
    {
        Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Opaque"}
        ZWrite On Lighting Off Cull Off Fog { Mode Off } Blend One Zero

        GrabPass { "_GrabTexture" }
        
        Pass 
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            sampler2D _GrabTexture;

            struct vin_vct
            {
                float4 vertex : POSITION;
            };

            struct v2f_vct
            {
                float4 vertex : POSITION;
                float4 uvgrab : TEXCOORD1;
            };

            // Vertex function 
            v2f_vct vert (vin_vct v)
            {
                v2f_vct o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.uvgrab = ComputeGrabScreenPos(o.vertex); // tính vị trí hiện tại của vật thể so với máy ảnh
                return o;
            }

            // Fragment function
            half4 frag (v2f_vct i) : COLOR
            {
                fixed4 col = tex2Dproj( _GrabTexture, UNITY_PROJ_COORD(i.uvgrab));
                return col;
            }
        
            ENDCG
        } 
    }
}

_BumpMap ("Noise text", 2D) = "bump" {}

half4 bump = tex2D(_BumpMap, i.texcoord);
half2 distortion = UnpackNormal(bump).rg; // From 0..1 to -1..+1

// Putting everything together...
// Mặc dù được sử dụng cho kính, kỹ thuật shading  này hoàn hảo cho các hiệu ứng khác chẳng hạn như nước chảy, sóng xung kích do vụ nổ của nhiễu loạn không khí do lửa tạo ra.
Shader "Custom/GlassShader" 
{
    Properties 
    {
        _MainTex ("Base (RGB) Trans (A)", 2D) = "white" {}
        _Colour ("Colour", Color) = (1,1,1,1)

        _BumpMap ("Noise text", 2D) = "bump" {}
        _Magnitude ("Magnitude", Range(0,1)) = 0.05
    }
    
    SubShader
    {
        Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Opaque"}
        ZWrite On Lighting Off Cull Off Fog { Mode Off } Blend One Zero

        GrabPass { "_GrabTexture" }
        
        Pass 
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            sampler2D _GrabTexture;

            sampler2D _MainTex;
            fixed4 _Colour;

            sampler2D _BumpMap;
            float  _Magnitude;

            struct vin_vct
            {
                float4 vertex : POSITION;
                float4 color : COLOR;
                float2 texcoord : TEXCOORD0;
            };

            struct v2f_vct
            {
                float4 vertex : POSITION;
                fixed4 color : COLOR;
                float2 texcoord : TEXCOORD0;

                float4 uvgrab : TEXCOORD1;
            };

            // Vertex function 
            v2f_vct vert (vin_vct v)
            {
                v2f_vct o;
                o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
                o.color = v.color;

                o.texcoord = v.texcoord;

                o.uvgrab = ComputeGrabScreenPos(o.vertex);

                // Để giải quyết vấn đề mọi thứ lộn ngược (do sự không nhất quán giữa cách các phiên bản Unity3D khác nhau diễn giải dữ liệu UV) 
                #if UNITY_UV_STARTS_AT_TOP
                o.uvgrab.y *= -1;
                #endif

                return o;
            }

            // Fragment function
            half4 frag (v2f_vct i) : COLOR
            {
                half4 mainColour = tex2D(_MainTex, i.texcoord);
                
                half4 bump = tex2D(_BumpMap, i.texcoord);
                half2 distortion = UnpackNormal(bump).rg;

                i.uvgrab.xy += distortion * _Magnitude;

                fixed4 col = tex2Dproj( _GrabTexture, UNITY_PROJ_COORD(i.uvgrab));
                return col * mainColour * _Colour;
            }
        
            ENDCG
        } 
    }
}

// Shader này sử dụng ba kết cấu:
// _GrabTexture: kết cấu đã được lấy trước đó;
// _NoiseTex: kết cấu chứa Noise ngẫu nhiên được sử dụng để tăng vẻ ngoài ngẫu nhiên của nước;
// _CausticTex: một kết cấu phản chiếu ăn da, được sử dụng để mang lại cảm giác chân thực hơn cho mặt nước.
...
// Fragment function
fixed4 frag (v2f_vct i) : COLOR {
    fixed4 noise = tex2D(_NoiseTex, i.texcoord); // _NoiseTex: tăng vẻ ngoài ngẫu nhiên của nước
    fixed4 mainColour = tex2D(_MainTex, i.texcoord);
            
    float time = _Time[1];

    float2 waterDisplacement =
    sinusoid // gọi hàm 'sinusoid' được định nghĩa ở dưới!
    (
        float2 (time, time) + (noise.xy) * _offset,
        float2(-_waterMagnitude, -_waterMagnitude),
        float2(+_waterMagnitude, +_waterMagnitude),
        float2(_waterPeriod, _waterPeriod)
    );
                
    i.grabUV.xy += waterDisplacement;
    fixed4 col = tex2Dproj( _GrabTexture, UNITY_PROJ_COORD(i.grabUV));
    fixed4 causticColour = tex2D(_CausticTex, i.texcoord.xy*0.25 + waterDisplacement*5); // _CausticTex: cảm giác chân thực hơn cho mặt nước
    return col * mainColour * _waterColour * causticColour;
}

// Thay vì dựa _SinTime, chúng ta sử dụng hàm 'sin' để kiểm soát tốt hơn. Công việc của nó là tạo một sóng hình sin tùy chỉnh có thời gian tối thiểu, tối đa và chu kỳ đã biết.
float2 sinusoid (float2 x, float2 m, float2 M, float2 p) {
    float2 e   = M - m;
    float2 c = 3.1415 * 2.0 / p;
    return e / 2.0 * (1.0 + sin(x * c)) + m;
}
...

#include "UnityCG.cginc"

struct vertOutput {
    float4 pos : SV_POSITION;    // Clip space
    fixed4 color : COLOR;        // Vertex colour
    float2 texcoord : TEXCOORD0;    // UV data

    // wPos, sPos và cPos không có ngữ nghĩa ràng buộc thực sự (binding semantics).
    // TEXCOORD thường được sử dụng ngay cả khi chúng không chứa bất kỳ thông tin trực tiếp nào về dữ liệu UV.
    float3 wPos : TEXCOORD1;    // World position
    float4 sPos : TEXCOORD2;    // Screen position
    float3 cPos : TEXCOORD3;    // Object center in world
};

vertOutput vert (appdata_full v)
{
    vertOutput o;
    o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
    o.color = v.color;
    o.texcoord = v.texcoord;

    o.wPos = mul(_Object2World, v.vertex).xyz;
    o.sPos = ComputeScreenPos(o.pos);
    o.cPos = mul(_Object2World, half4(0,0,0,1));

    return o;
}
    
half4 frag (vertOutput i) : COLOR
{
    i.sPos.xy /= i.sPos.w;
    // ...rest of the shader
}

// Ví dụ: hiệu ứng xử lý hậu kỳ (postprocessing) có thể được sử dụng để chuyển hình ảnh có màu sang thang độ xám.
// Tên của nó bắt đầu bằng 'Hidden/' nên sẽ không xuất hiện trong menu Masterial Inspector vì Shader này không nhằm mục đích sử dụng Material và Model.
Shader "Hidden/BWDiffuse" {
    Properties {
        _MainTex ("Base (RGB)", 2D) = "white" {}
        _bwBlend ("Black & White blend", Range (0, 1)) = 0
    }
    SubShader {
        Pass {
            // Shader này sẽ không làm thay đổi hình dạng, do đó không cần 'vertex function'
            CGPROGRAM
            #pragma vertex vert_img // “empty” vertex function
            #pragma fragment frag

            #include "UnityCG.cginc"

            uniform sampler2D _MainTex;
            uniform float _bwBlend;

            // sử dụng cấu trúc tiêu chuẩn do Unity3D cung cấp là 'v2f_img'.
            float4 frag(v2f_img i) : COLOR {
                float4 c = tex2D(_MainTex, i.uv); // lấy màu của pixel hiện tại từ _MainTex
                
                float lum = c.r*.3 + c.g*.59 + c.b*.11; // tính toán phiên bản thang độ xám của 'c'.
                float3 bw = float3( lum, lum, lum ); 
                
                float4 result = c;
                result.rgb = lerp(c.rgb, bw, _bwBlend); // nội suy màu gốc và màu mới bằng cách sử dụng _bwBlend làm hệ số hòa trộn.
                return result;
            }
            ENDCG
        }
    }
}

using UnityEngine;
using System.Collections;

[ExecuteInEditMode]
public class BWEffect : MonoBehaviour {

    public float intensity;
    private Material material; // Chúng ta có thể cung cấp tài liệu trực tiếp từ Inspector, nhưng có nguy cơ tài liệu đó bị chia sẻ giữa các Instance khác của BWEffect.

    // Creates a private material used to the effect
    void Awake ()
    {
        material = new Material( Shader.Find("Hidden/BWDiffuse") ); // Nên cung cấp chính Shader cho tập lệnh, thay vì sử dụng tên của nó Find("Hidden/BWDiffuse")
    }
    
    // Postprocess the image
    void OnRenderImage (RenderTexture source, RenderTexture destination)
    {
        if (intensity == 0)
        {
            Graphics.Blit (source, destination); // nếu cường độ bằng 0 thì không can thiệp gì Shader và đầu ra của hiển thị
            return; // bỏ qua việc sử dụng shader
        }

        material.SetFloat("_bwBlend", intensity); // Truyền sang Shader '_bwBlend'
        Graphics.Blit (source, destination, material); // Hàm Blit lấy một RenderTexture nguồn, xử lý nó bằng vật liệu được cung cấp và hiển thị nó ở đích đã chỉ định. 
    }
}