计算机图形学

Shader "Example/SimpleShader" {
    Properties {
        // 定义一个属性，可以在材质面板上选择颜色
        _Color ("Color Tint", Color) = (1, 1, 1, 1)
    }

    SubShader {
        Pass {
            CGPROGRAM

            #include "UnityCG.cginc"

            // 告诉编译器 vert 是顶点着色器
            #pragma vertex vert
            // 告诉编译器 frag 是片元着色器
            #pragma fragment frag


            // uniform 关键词是 Cg 中用于修饰变量和参数的一种修饰词
            // 它仅仅用于提供一些关于该变量的初始值是如何制定和存储的相关信息
            uniform fixed4 _Color;


            // 使用一个结构体定义顶点着色器的输入
            // POSITION、NORMAL、TEXCOORD0 语义的数据来自哪里？
            // 它们由该材质的 Mesh Render 组件提供，在每帧调用 Draw Call 的时候
            // Mesh Render 组件会把它负责渲染的模型数据发送给 Unity Shader
            struct a2v {
                // vertex 包含了顶点的位置，通过 POSITION 语义指定的
                // POSITION 语义告诉 Unity 用模型空间的顶点坐标填充 vertex 变量
                float4 vertex : POSITION;

                // NORMAL 语义告诉 Unity 用模型空间的法线向量填充 normal 变量
                float3 normal : NORMAL;

                // TEXCOORD0 语义告诉 Unity 用模型的第一套纹理坐标填充 texcoord 变量
                float4 texcoord : TEXCOORD0;
            };

            // 使用一个结构体定义顶点着色器的输出
            // 用于在顶点着色器和片元着色器之间传输信息
            struct v2f {
                // SV_POSITION 语义表示顶点在裁剪空间的位置
                // SV_POSITION 语义告诉 Unity，pos 里包含了顶点在裁剪空间中的位置信息
                // 否则，渲染器将无法得到裁剪空间中的顶点坐标，也无法将顶点渲染到屏幕上
                float4 pos : SV_POSITION;

                // COLOR0 语义 可用于存储颜色信息
                // COLOR0 语义中的数据可以由用户自己定义，但一般存储颜色，比如逐顶点的漫反射颜色或者逐顶点的高光反射颜色
                // 类似的语义还有 COLOR1 等
                fixed3 color : COLOR0;
            };


            // 顶点着色器时流水线的第一个阶段，它的输入来自CPU
            // 顶点着色器的处理单位是顶点，也就是说，输入进来的每个顶点都会调用一次顶点着色器
            // 顶点着色器本身不可以创建或者销毁任何顶点，而且无法得到顶点与顶点之间的关系
            // 例如，无法得知两个顶点是否属于同一个三角形网格
            // 正是因为这种相互独立性，GPU 可以利用本身的特性并发化处理每个顶点，这个阶段的处理速度非常快
            v2f vert(a2v v) {
                v2f o;

                // 下面一行，等价于 o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
                // UNITY_MATRIX_MVP 当前的模型观察投影矩阵，用于将顶点/方向矢量从模型空间变换到裁剪空间
                o.pos = UnityObjectToClipPos(v.vertex);

                // v.normal 包含了顶点的法线向量，其分量范围在[-1.0, 1.0]
                // 下面的代码将分量范围映射到 [0.0, 1.0]
                // 存储到 o.color 中传递给片元着色器
                o.color = v.normal * 0.5 + fixed3(0.5, 0.5, 0.5);
                return o;
            }


            // 片元着色器是逐片元执行的
            // 片元大致可以认为对应屏幕像素，或者说render target上的像素，在透视投影下，离得近的模型占的屏幕面积大，自然片元就更多
            // 片元着色器的输入实际上是把顶点着色器的输出进行插值后得到的结果
            fixed4 frag(v2f i) : SV_Target {
                fixed3 c = i.color;

                // 使用 _Color 属性来控制输出颜色
                c *= _Color.rbg;

                // 将插值后的 i.color 显示到屏幕上
                return fixed4(c, 1.0);
            }

            ENDCG
        }
    }
}

o.vertex = UnityObjectToClipPos(v.vertex);

// 等价于
o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);

struct vertOut {
    float4 pos: SV_POSITION;
    float4 srcPos: TEXCOORD0;
};

vertOut vert(appdata_base v) 
{
    vertOut o;
    o.pos = mul(UNITY_MATRIX_MVP, v.vertex);

    // 第一步，把ComputeScreenPos()的结果保存在srcPos
    o.srcPos = ComputeScreenPos(o.pos);

    return o;
}

fixed4 frag(vertOut i) : SV_Target
{
    // 第二步：用srcPos.xy 除以srcPos.w 得到视口空间中的坐标
    float2 wcoord = (i.srcPos.xy / i.srcPos.w);
    return fixed4(wcoord, 0.0, 1.0);
}

struct v2f {
    float4 pos : SV_POSITION;
    float3 worldNormal : TEXCOORD0;
};

v2f vert(a2v v)
{
    v2f o;
    // Transform the vertex from object space to projection space
    o.pos = mul(UNITY_MATRIX_MVP, v.vertex);

    // Transform the normal from object space to world space
    o.worldNormal = mul(v.normal, (float3x3)_World2Object);
}

fixed4 frag(v2f i): SV_Target
{
    // 获取环境光
    fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz;

    // 对世界空间的法线向量进行归一化
    fixed3 worldNormal = normalize(i.worldNormal);
    // 获取世界空间中的光线方向。但如果场景中有多个光源且可能是点光源，直接使用_WorldSpaceLightPos0 就不能得到正确的结果
    fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);

    // 使用公式计算漫反射
    fixed3 diffuse = _LightColot0.rgb * _Diffuse.rgb * saturate(dot(worldNormal, worldLightDir));

    // 环境光和漫反射光部分进行相加
    fixed3 color = ambient + diffuse;

    return fixed4(color, 1.0);
}

#define TRANSFORM_TEX(tex, name) (tex.xy * name##_ST.xy + name##_ST.zw)

// 先使用缩放属性.xy 对顶点纹理坐标进行缩放
// 然后使用偏移属性.zw 对结果进行偏移

// 第一个参数是顶点纹理坐标
// 第二个参数是纹理名

Shader "Unity Shaders Book/Chapter 7/Single Texture" {
    Properties {
        _Color ("Color Tint", Color) = (1, 1, 1, 1)

        // 纹理属性
        _MainTex ("Main Tex", 2D) = "white" {}

        // 控制高光反射颜色
        _Specular ("Specular", Color) = (1, 1, 1, 1)

        // 控制高光区域大小
        _Gloss ("Gloss", Range(8.0, 256)) = 20
    }
    SubShader {     
        Pass { 
            Tags { "LightMode"="ForwardBase" }
        
            CGPROGRAM
            
            #pragma vertex vert
            #pragma fragment frag

            #include "Lighting.cginc"
            
            fixed4 _Color;
            sampler2D _MainTex;
            float4 _MainTex_ST;     // 使用 纹理名_ST 的方式来声明纹理的属性。其中ST 是缩放(scale) 和平移(translation) 的缩写，.xy 存储的是缩放值。.zw 存储的是偏移值
            fixed4 _Specular;
            float _Gloss;
            
            struct a2v {
                float4 vertex : POSITION;
                float3 normal : NORMAL;

                // TEXCOORD0 语义，Unity 将模型的第一组纹理坐标存储到该变量
                float4 texcoord : TEXCOORD0;
            };
            
            struct v2f {
                float4 pos : SV_POSITION;
                float3 worldNormal : TEXCOORD0;
                float3 worldPos : TEXCOORD1;

                // 用于存储纹理坐标的变量uv，以便在片元着色器中使用该变量进行纹理采样
                float2 uv : TEXCOORD2;
            };
            
            v2f vert(a2v v) {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                
                o.worldNormal = UnityObjectToWorldNormal(v.normal);
                
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                // 使用纹理的属性值_MainTex_ST 对顶点纹理坐标进行变换，得到最终的纹理坐标
                // 先使用缩放属性.xy 对顶点纹理坐标进行缩放
                // 然后使用偏移属性.zw 对结果进行偏移
                o.uv = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                // Or just call the built-in function
//              o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
                
                return o;
            }
            
            fixed4 frag(v2f i) : SV_Target {
                // 先计算了世界空间下的法线向量和光照方向
                fixed3 worldNormal = normalize(i.worldNormal);
                fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
                

                // 使用tex2D() 函数对纹理进行采样
                // 第一个参数需要被采样的纹理，第二个参数是一个float2 类型的纹理坐标
                // 函数返回计算得到的纹素值
                // 使用采样结果和颜色属性_Color 的乘积来作为材质的反射率 albedo
                // Use the texture to sample the diffuse color
                fixed3 albedo = tex2D(_MainTex, i.uv).rgb * _Color.rgb;
                
                // 反射率albedo 与环境光照相乘得到环境光部分
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
                
                // 使用albedo 来计算漫反射光照的结果
                fixed3 diffuse = _LightColor0.rgb * albedo * max(0, dot(worldNormal, worldLightDir));
                
                fixed3 viewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
                fixed3 halfDir = normalize(worldLightDir + viewDir);
                fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(max(0, dot(worldNormal, halfDir)), _Gloss);
                

                // 环境光、漫反射、高光反射光照相加返回
                return fixed4(ambient + diffuse + specular, 1.0);
            }
            
            ENDCG
        }
    } 
    FallBack "Specular"
}

Shader "Unity Shaders Book/Chapter 14/Toon Shading" {
    Properties {
        _Color ("Color Tint", Color) = (1, 1, 1, 1)
        _MainTex ("Main Tex", 2D) = "white" {}

        // _Ramp 是用于控制漫反射色调的渐变纹理，后面会有说明
        _Ramp ("Ramp Texture", 2D) = "white" {}

        // 用于控制轮廓线宽度
        _Outline ("Outline", Range(0, 1)) = 0.1

        // 用于控制轮廓线颜色
        _OutlineColor ("Outline Color", Color) = (0, 0, 0, 1)

        // 高光反射颜色
        _Specular ("Specular", Color) = (1, 1, 1, 1)

        // 用于控制计算高光反射时使用的阈值
        _SpecularScale ("Specular Scale", Range(0, 0.1)) = 0.01
    }

    SubShader {
        Tags { "RenderType"="Opaque" "Queue"="Geometry"}
        
        // 定义渲染轮廓线需要的Pass，这个Pass 只渲染背面的三角面片
        Pass {
            // 使用NAME 命令为该Pass 定义了名称，这是因为描边在非真实感渲染中是非常常见的效果
            // 为该Pass 定义名称可以让我们在后面的使用中不需要再重复编写此Pass，只需要调用它的名字即可
            NAME "OUTLINE"
            
            // 只渲染背面，所以使用Cull 指令把正面的三角面片剔除
            Cull Front
            
            CGPROGRAM
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
            
            float _Outline;
            fixed4 _OutlineColor;
            
            struct a2v {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
            }; 
            
            struct v2f {
                float4 pos : SV_POSITION;
            };
            

            // 定义描边需要的顶点着色器
            v2f vert (a2v v) {
                v2f o;
                
                // 把顶点、法线变换到视角空间（观察空间）下，这是为了让描边可以在观察空间达到最好的效果
                float4 pos = float4(UnityObjectToViewPos(v.vertex), 1.0);
                float3 normal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);

                // 设置法线的z 分量，对其归一化后再将顶点沿其方向扩展，得到扩展后的顶点坐标
                // 对法线的处理是为了尽可能避免背面扩张后的顶点挡住正面的面片
                normal.z = -0.5;
                pos = pos + float4(normalize(normal), 0) * _Outline;

                // 最后把顶点从视角空间变换到裁剪空间
                o.pos = mul(UNITY_MATRIX_P, pos);
                
                return o;
            }
            
            // 片元着色器很简单，只需要用轮廓线颜色渲染整个背面即可
            float4 frag(v2f i) : SV_Target { 
                return float4(_OutlineColor.rgb, 1);               
            }
            
            ENDCG
        }
        

        // 定义光照模型所在的Pass，以渲染模型的正面
        // 由于光照模型需要使用Unity 提供的光照等信息，需要为Pass 进行相应的设置
        Pass {
            Tags { "LightMode"="ForwardBase" }
            
            // 这次只渲染正面，所以剔除模型的背面
            Cull Back
        
            CGPROGRAM
        
            #pragma vertex vert
            #pragma fragment frag
            
            // 添加相应的编译指令，都是为了让Shader 中的光照变量可以被正确赋值
            #pragma multi_compile_fwdbase
        
            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            #include "AutoLight.cginc"
            #include "UnityShaderVariables.cginc"
            
            fixed4 _Color;
            sampler2D _MainTex;
            float4 _MainTex_ST;
            sampler2D _Ramp;
            fixed4 _Specular;
            fixed _SpecularScale;
        
            struct a2v {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float4 texcoord : TEXCOORD0;
                float4 tangent : TANGENT;
            }; 
        
            struct v2f {
                float4 pos : POSITION;
                float2 uv : TEXCOORD0;
                float3 worldNormal : TEXCOORD1;
                float3 worldPos : TEXCOORD2;
                SHADOW_COORDS(3)
            };
            
            v2f vert (a2v v) {
                v2f o;
                
                o.pos = UnityObjectToClipPos( v.vertex);
                o.uv = TRANSFORM_TEX (v.texcoord, _MainTex);

                // 计算世界空间下的法线向量和顶点位置
                o.worldNormal  = UnityObjectToWorldNormal(v.normal);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                
                // 使用Unity 内置的宏TRANSFER_SHADOW 计算阴影所需要的各个变量
                TRANSFER_SHADOW(o);
                
                return o;
            }
            

            // 片元着色器中包含了计算光照模型的关键代码
            float4 frag(v2f i) : SV_Target { 
                // 对世界空间下的法线向量归一化
                fixed3 worldNormal = normalize(i.worldNormal);

                // 对
                fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
                fixed3 worldViewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
                fixed3 worldHalfDir = normalize(worldLightDir + worldViewDir);
                
                //
                fixed4 c = tex2D (_MainTex, i.uv);
                // 计算材质的反射率albedo
                fixed3 albedo = c.rgb * _Color.rgb;
                
                // 计算环境光照ambient
                fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
                
                // 使用Unity 内置的宏UNITY_LIGHT_ATTENUATION 计算当前世界坐标系下的阴影值
                UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
                
                // 计算半兰伯特漫反射系数
                fixed diff =  dot(worldNormal, worldLightDir);
                // 并和阴影值相乘得到最终的漫反射系数
                diff = (diff * 0.5 + 0.5) * atten;
                
                // 使用这个漫反射系数对渐变纹理_Ramp 进行采样
                // 并将结果和材质的反射率、光照颜色相乘，作为最后的漫反射光照
                fixed3 diffuse = _LightColor0.rgb * albedo * tex2D(_Ramp, float2(diff, diff)).rgb;
                
                // 计算高光
                fixed spec = dot(worldNormal, worldHalfDir);
                // 使用fwidth() 对高光区域的边界进行抗锯齿处理
                fixed w = fwidth(spec) * 2.0;
                // 最后还使用step(0.0001, _SpecularScale)，这是为了在_SpecularScale 为0 时，可以完全消除高光反射的光照
                fixed3 specular = _Specular.rgb * lerp(0, 1, smoothstep(-w, w, spec + _SpecularScale - 1)) * step(0.0001, _SpecularScale);
                
                // 最后，返回环境光照、漫反射光照和高光反射叠加的结果
                return fixed4(ambient + diffuse + specular, 1.0);
            }
        
            ENDCG
        }
    }
    FallBack "Diffuse"
}