Shader "Unlit/Matcap"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Matcap("Mapcap",2D) = "white"{}
        _MatcapPower("MatcapPower", Float) = 2
        _MatcapAdd("MapcapAdd",2D) = "white"{}
        _MatcapAddPower("MatcapAddPower", Float) = 2
        _RampTex("RampTex",2D) = "white"{}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM 
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float3 normal :NORMAL;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
                float3 normal_world:TEXCOORD1;
                float3 pos_world:TEXCOORD2;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            sampler2D _Matcap;
            float _MatcapPower;
            sampler2D _MatcapAdd;
            float _MatcapAddPower;
            sampler2D _RampTex;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                o.normal_world = mul(float4(v.normal,0), unity_WorldToObject);
                o.pos_world = mul(unity_ObjectToWorld, v.vertex).xyz;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                //主贴图
                float4 tex_color = tex2D(_MainTex,i.uv);

                //Matcap 计算采样的uv  使用
                float3 normal_world = normalize(i.normal_world);
                float3 normal_view = mul(UNITY_MATRIX_V, float4(normal_world,0));
                float2 map_cap_uv = (normal_view.xy + float2(1,1)) * 0.5;
                float4 mapcap_color = tex2D(_Matcap, map_cap_uv) * _MatcapPower;

                //叠加的 Matcap
                float4 matcap_add = tex2D(_MatcapAdd, map_cap_uv) * _MatcapAddPower; 

                //用菲涅尔来采样渐变图 1-0
                float3 view_world = normalize(_WorldSpaceCameraPos.xyz - i.pos_world);
                half NdotV = saturate(dot(normal_world,view_world));
                half sample = 1 - NdotV;
                float4 ramp_color = tex2D(_RampTex, float2(sample,sample));

                float4 final_color = mapcap_color * tex_color * ramp_color + matcap_add;
                return final_color;
            }
            ENDCG
        }
    }
}

Matcap贴图

可以用一张渐变图和一张噪声图，一个圆形的模型，通过透明测试制作效果。

Shader "Clip/Bo" 
{
	
	Properties 
	{
		_MainTex ("Texture", 2D) = "" {}
		_MainColor("Main Color",Color) = (1,1,1,1)
		_NoiseMap("NoiseMap", 2D) = "" {}
		_Cutout("Cutout", Range(0.0,1.1)) = 0.0
		_Speed("Speed", Vector) = (.34, .85, .92, 1)
	}
	SubShader
	{
		Tags { "RenderType"="Opaque" "DisableBatching"="True"} 
		Pass 
		{
			CGPROGRAM 
			#pragma vertex vert
			#pragma fragment frag
			#include "UnityCG.cginc" 
			struct appdata 
			{
				float4 vertex : POSITION; 
				half2 texcoord0 : TEXCOORD0; 
			};

			struct v2f  
			{
				float4 pos : SV_POSITION;
				float4 uv : TEXCOORD0; 
			};

			sampler2D _MainTex;
			float4 _MainTex_ST;
			float _Cutout;
			float4 _Speed;
			sampler2D _NoiseMap;
			float4 _NoiseMap_ST;
			float4 _MainColor;
			
			//顶点Shader
			v2f vert (appdata v)
			{
				v2f o;
				o.pos = UnityObjectToClipPos(v.vertex);
				o.uv.xy = TRANSFORM_TEX(v.texcoord0, _MainTex);
				o.uv.zw = TRANSFORM_TEX(v.texcoord0, _NoiseMap);
				return o;
			}
			//片元Shader
			half4 frag (v2f i) : SV_Target 
			{
				half gradient = tex2D(_MainTex, i.uv.xy + _Time.y * 0.1f * _Speed.xy).r * (1.0 - i.uv.y);
				half noise = 1.0 - tex2D(_NoiseMap, i.uv.zw + _Time.y * 0.1f * _Speed.zw).r;
				clip(gradient - noise -  _Cutout);
				return _MainColor;
			}
			ENDCG
		}
	}
}

Shader "Custom/RubCard" {
Properties {
   _Color ("Main Color", Color) = (1,1,1,1)//Tint Color
   _MainTex ("Base (RGB)", 2D) = "white" {}
   _MainTex_2 ("Base (RGB)", 2D) = "white" {}
   ratioY ("ratioY", Float) = 0
   radius ("radius", Float) = 0
   height ("height", Float) = 0
   anchorY ("anchorY", Float) = 0
   rubOffset ("rubOffset", Float) = 0
   maxRubAngle ("maxRubAngle", Float) = 0
   _ZOffsetOne("ZOffsetOne",Float)=0
   _ZOffsetTwo("ZOffsetTwo",Float)=0
   _Move("Move",Float)=0
}
 
SubShader {
   Tags {"Queue"="Geometry"  "RenderType"="Opaque" }
   LOD 100
   
   Pass {
      Name "ONE"
      Tags{"LightMode" = "UniversalForward"}
      Cull Front
      Lighting Off

        CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
            #include "Lighting.cginc"
         
            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _Color;
            float ratioY;
            float radius;
            float height;
            float anchorY;
            float rubOffset;
            float maxRubAngle;
            float _ZOffsetOne;
            float _Move;

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
            
            v2f vert (appdata v)
            {
                v2f o;
                float4 tmp_pos = v.vertex;
                float tempAngle = 1.0;

        
                tmp_pos.xyz = mul(unity_ObjectToWorld,float4(tmp_pos.xyz,0)).xyz;
                float pi = 3.14159;
                float halfPeri = radius * pi * maxRubAngle; 
                float rubLenght = height * (ratioY - anchorY);
                tmp_pos.y += height*rubOffset;
                float tempPosY = tmp_pos.y;
                if(tmp_pos.y < rubLenght)
                {
                        float dy = (rubLenght - tmp_pos.y);
                    if(rubLenght - halfPeri < tmp_pos.y)
                    {
                        float angle = dy/radius;
                        tmp_pos.y = rubLenght -  sin(angle)*radius;
                        tmp_pos.z = radius * (1.0- cos(angle)); 
                    }
                    else
                    {
                        float tempY = rubLenght  - halfPeri - tmp_pos.y;
                        float tempAngle = pi * (1.0-maxRubAngle);
                        tmp_pos.y = rubLenght - radius*sin(tempAngle) + tempY * cos(tempAngle);
                        tmp_pos.z = radius + radius*cos(tempAngle) + tempY * sin(tempAngle);

                    }

                }
                tmp_pos.x += unity_ObjectToWorld[3][0];
                tmp_pos.y += unity_ObjectToWorld[3][1];
                tmp_pos.z += unity_ObjectToWorld[3][2];

                
                float4 pos = mul(UNITY_MATRIX_VP, tmp_pos);


                float tempOffset = _ZOffsetOne * pos.w;
                if (tempPosY < rubLenght )
                {
                    float dy = (rubLenght - tempPosY);
                    if( dy > pi * radius)
                    {
                        tempOffset = -tempOffset*2.0;
                    }
                }

                pos.z = pos.z + tempOffset;
                pos.x += _Move;

                o.vertex = pos;
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                o.uv.x = 1 - o.uv.x;//对uv的x取反
                return o;
            }
            
            fixed4 frag (v2f i) : SV_Target
            {

                fixed4 col = tex2D(_MainTex, i.uv);
                clip (col.a - 0.5);
                return col * _Color;
            }
            ENDCG
   }

     Pass
        {
            Name "TWO"
          Cull Back
          Lighting Off

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

         

            sampler2D _MainTex_2;
            float4 _MainTex_2_ST;
            fixed4 _Color;
            float ratioY;
            float radius;
            float height;
            float anchorY;
            float rubOffset;
            float maxRubAngle;
            float _ZOffsetTwo;
            float _Move;

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
            
            v2f vert (appdata v)
            {
                v2f o;
                float4 tmp_pos = v.vertex;
                float tempAngle = 1.0;

        
                tmp_pos.xyz = mul(unity_ObjectToWorld,float4(tmp_pos.xyz,0)).xyz;
                //tmp_pos.xyz = (modelMatrix * vec4(tmp_pos.xyz, 0.0)).xyz;
                float pi = 3.14159;
                float halfPeri = radius * pi * maxRubAngle; 
                float rubLenght = height * (ratioY - anchorY);
                tmp_pos.y += height*rubOffset;
                float tempPosY = tmp_pos.y;
                if(tmp_pos.y < rubLenght)
                {
                        float dy = (rubLenght - tmp_pos.y);
                    if(rubLenght - halfPeri < tmp_pos.y)
                    {
                        float angle = dy/radius;
                        tmp_pos.y = rubLenght -  sin(angle)*radius;
                        tmp_pos.z = radius * (1.0- cos(angle)); 
                    }
                    else
                    {
                        float tempY = rubLenght  - halfPeri - tmp_pos.y;
                        float tempAngle = pi * (1.0-maxRubAngle);
                        tmp_pos.y = rubLenght - radius*sin(tempAngle) + tempY * cos(tempAngle);
                        tmp_pos.z = radius + radius*cos(tempAngle) + tempY * sin(tempAngle);

                    }

                }
                tmp_pos.x += unity_ObjectToWorld[3][0];
                tmp_pos.y += unity_ObjectToWorld[3][1];
                tmp_pos.z += unity_ObjectToWorld[3][2];

                
                float4 pos = mul(UNITY_MATRIX_VP, tmp_pos);


                float tempOffset = _ZOffsetTwo * pos.w;
                if (tempPosY < rubLenght )
                {
                    float dy = (rubLenght - tempPosY);
                    if( dy > pi* radius)
                    {
                        tempOffset = -tempOffset * 2.0;
                    }
                }
                pos.z = pos.z + tempOffset;
                pos.x += _Move;

                o.vertex = pos;
                o.uv = TRANSFORM_TEX(v.uv, _MainTex_2);
                o.uv.x = 1 - o.uv.x;//对uv的x取反
                o.uv.y = 1 - o.uv.y;//对uv的y取反
                return o;
            }
            
            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex_2, i.uv);
                clip (col.a - 0.5);
                return col * _Color;
            }
            ENDCG
        }

    
}
}

注意：URP要渲染多通道的shader，需要确保有个pass打上UniversalForward的tag，其余pass有SRPDefaultUnlit的tag也行，没有也行

shader将模型坐标转换为世界坐标，所以普通的移动不会影响位置，需要调节shader的参数做偏移，调节参数把牌摆好，设置好角度和相机角度。

Shader "Custom/lookSuface" 
{
	Properties
	{
		_Color ("Main Color",Color) = (1,1,1,1)
		_MainTex("Base (RGB)",2D) = "white"{}
		_BumpMap("Normalmap",2D) = "bump" {}
	}

	SubShader
	{
		Tags{"RenderType" = "Opaque"}
		LOD 300

		CGPROGRAM
		#pragma surface surf Lambert  //定义表面着色函数，指定使用兰伯特光照模型  
		#pragma target 3.0

		sampler2D _MainTex;
		sampler2D _BumpMap;
		fixed4 _Color;

		struct Input
		{
			float2 uv_MainTex;
			float2 uv_BumpMap;
		};

		void surf(Input IN, inout SurfaceOutput o)
		{
			fixed4 tex = tex2D(_MainTex, IN.uv_MainTex);
			o.Albedo = tex.rgb * _Color.rgb;
			o.Alpha = tex.a * _Color.a;
			o.Normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
		}
		ENDCG
	}

	FallBack "Diffuse"
}

Shader "Unlit/KaTong"
{
	Properties
	{
		_MainTex ("Texture", 2D) = "white" {}//主帖图
		_Color("Color Tint",Color) = (1,1,1,1)//颜色
		_Ramp("Ramp Texture",2D) = "white" {}//渐变贴图
		_Outline("Outline",Range(0,1)) = 0.1//描边大小
		_OutlineColor ("Outline Color",Color) = (1,1,1,1) //描边的颜色
		_Specular ("Specular",Color) = (1,1,1,1) //高光颜色
		_SpecularScale("Specular Scale",Range(0,0.1)) = 0.01 //高光缩放，范围
	}
	SubShader
	{
		Tags { "RenderType"="Opaque" }
		LOD 100

		Pass
		{
			NAME "OUTLINE"
			Cull Front // 渲染背面，大一点，把边缘露出来
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			
			#include "UnityCG.cginc"

			struct appdata
			{
				float4 vertex : POSITION;
				float3 normal :NORMAL;
			};

			struct v2f
			{
				float4 vertex : SV_POSITION;
			};

			float4 _OutlineColor;
			float _Outline;
			
			v2f vert (appdata v)
			{
				v2f o;
				float4 pos = mul(UNITY_MATRIX_MV, v.vertex);//变换顶点到观察空间
				//变换法线到观察空间，UNITY_MATRIX_IT_MV是专门针对法线的变换矩阵，法线非等比变换会使角度改变，所以使用的矩阵和顶点变换的是不一样的
				float3 normal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);
				//对法线的z轴处理在normalize 是为了防止背面顶点扩张挡住正面
				normal.z = -0.5;
				pos = pos + float4(normalize(normal), 0) * _Outline;
				o.vertex = mul(UNITY_MATRIX_P, pos);//在变换到检查矩阵
				return o;
			}
			
			fixed4 frag (v2f i) : SV_Target
			{
				//渲染成描边颜色就可以了
				return float4(_OutlineColor.rgb,1);
			}
			ENDCG
		}

		Pass{
			Tags{"LightMode"="ForwardBase"}

			Cull Back

			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			#pragma multi_compile_fwdbase

			#include "UnityCG.cginc"
			#include "Lighting.cginc"
			#include "AutoLight.cginc"

			struct v2f
			{
				float4 vertex : SV_POSITION;
				float2 uv:TEXCOORD0;
				float3 worldNormal:TEXCOORD1;
				float3 worldPos : TEXCOORD2;
			};

			sampler2D _MainTex;
			float4 _MainTex_ST;
			sampler2D _Ramp;
			float4 _Color;
			float4 _Specular;
			fixed _SpecularScale;

			v2f vert(appdata_base v)
			{
				//单单的变换坐标，计算世界顶点位置和世界顶点法线给片元
				v2f o;
				o.vertex = UnityObjectToClipPos(v.vertex);
				o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
				o.worldNormal = mul(unity_ObjectToWorld, v.normal);
				o.worldPos = mul(unity_ObjectToWorld, v.vertex);
				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);
				fixed3 albedo = c.rgb * _Color.rgb;
				fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
				UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);//光照衰减

				fixed diff = dot(worldNormal, worldLightDir);
				diff = (diff * 0.5 + 0.5) * atten; //半兰伯特漫反射
				fixed3 diffuse = _LightColor0.rgb * albedo * tex2D(_Ramp, float2(diff, diff)).rgb; //融合渐变纹理和环境颜色

				//卡通的高光都是一块一块的，也就是让它不是0就是1，然后在边缘的地方进行一些过度，减少突变
				fixed spec = dot(worldNormal, worldHalfDir);
				fixed w = fwidth(spec) * 2.0; //邻域像素之间的近似倒数值，用来作为平滑的区域
				//smoothstep 在[-w,w]外区域外的话 >w就为1，<-w的话就为0 在这区间的话就平滑为0-1
				fixed3 specular = _Specular.rgb * lerp(0, 1, smoothstep(-w, w, spec + _SpecularScale - 1)) * step(0.0001, _SpecularScale);
				//step(0.0001, _SpecularScale) 是为了_SpecularScale为0时，消除高光

				return fixed4(ambient + diffuse + specular, 1.0);
			}
			ENDCG
		}
	}
	Fallback Off
}

一个卡通效果思路就是，在漫反射的时候使用一个渐变纹理控制色调，高光是区块性的，再加一个描边效果。这里使用的是过程式几何轮廓线渲染，就是使用一个Pass用来渲染较大的背面当作边缘线，再用另外一个Pass渲染正面。

已知，一个坐标系中的顶点坐标可以通过它相对于另一个顶点坐标的偏移来求得。我们可以先知道摄像机在世界坐标下的位置，以及世界空间下该像素相对于摄像机的偏移量，把它们相加就可以得到改像素的世界坐标。

float4 worldPos = _WorldSpaceCameraPos + linearDepth * interpolatedRay;

linearDepth是由深度纹理得到的线性深度值，interpolatedRay是由顶点着色器输出并插值得到的射线，它不仅包含了该像素到摄像机的方向，也包含了距离信息。

怎么求这个interpolatedRay就是重点了。interpolatedRay来源于近裁剪平面的4个角的某个特定向量的插值，这4个向量包含了它们到摄像机的方向和距离信息，最后根据顶点比较偏向哪个角，就用那边的特定向量的线性插值来计算世界坐标。

//近剪裁面中心到top边的垂直距离
float halfHeight = near * Mathf.Tan(fov * 0.5f * Mathf.Deg2Rad);
//近剪裁面中心垂直指向左边
Vector3 toRight = cam.transform.right * halfHeight * aspect;
//近剪裁面中心垂直指向上边
Vector3 toTop = cam.transform.up * halfHeight;

Vector3 topLeft = cam.transform.forward * near - toRight + toTop;
float scale = topLeft.magnitude / near;//计算一个depth值转换成真实长度的scale

//相机指向近剪裁面的左上角
topLeft.Normalize();
topLeft *= scale;

//相机指向近剪裁面的右上角
Vector3 topRight = cam.transform.forward * near + toRight + toTop;
topRight.Normalize();
topRight *= scale;

//相机指向近剪裁面的右下角
Vector3 bottomRight = cam.transform.forward * near + toRight - toTop;
bottomRight.Normalize();
bottomRight *= scale;

各个方向乘以scale是因为通过深度贴图获取的linearDepth只是在z轴上的，而不是两点之间的距离，所以通过这个scale来转换过来，scale的由来（近似三角形）：