渲染管线位置

• 区分曲面还分为三阶段
  • Hull shader：定义一些细分的参数（如：每条边上如何细分，内部三角形如何细分）
  • Tessellation Primitive Generator，不可编程的，它负责真正的进行曲面细分，它利用上一步进来的patch，以及innersize ，outsize，以及space策略细分曲面
  • ​Domain shader：经过曲面细分着色器细分后的点是位于重心空间的，这部分的作用就是把它转化到我们要用的空间
• 在D3D11 和 OpenGL中，名字/叫法有差异

曲面细分着色器-Tessellation shader（TESS）

应用

• 海浪、雪地等

  • 将一条直线进行细分，向一条曲线慢慢逼近

  

• 常见的应用：和置换贴图（DIsplacement mapping，也叫位移贴图）结合使用

• 使用普通法线的模型，在边缘部分的凹凸感会不理想

• 如果使用置换贴图，因为它是真正改变物体的形状，所以边缘部分的凹凸感就会很真实

• 但使用置换贴图，对模型的面数有要求

  • 正是这个原因，让它和曲面细分着色器有着很好的契合度
  • 比起直接增加模型面数，使用细分曲面可以根据距离或者一些规则来动态调整模型的复杂度，带来更好的性能

  

TESS的输入和输出

• 输入

  • Patch，可以看成是多个顶点的集合，包含每个顶点的属性
  • 属性是所有顶点共享的，不是每个顶点有独自的属性

• 功能

  • 将图元进行细分，图元可以是三角形、矩形等
  • 不同的图元，输入参数也不一样

• 输出

  • 细分后的顶点

TESS的流程

Hull shader → Tessellation Primitive Generator → Domain shader

Hull shader

• 定义细分的参数

  • 设定Tessellation factor以及Inside Tessellation factor

• （如果需要的话）可以对输入的Patch参数进行改变

Tessellation Primitive Generator

• 这部分是不可编程、无法控制的
• 进行细分操作，它利用上一步进来的patch，以及innersize ，outsize，以及space策略细分曲面

Domain shader

• 对细分后的点进行处理，从重心空间（Barycentric coordinate system）转换到屏幕空间

Hull shader参数详解

Tessellation Factor

• 用途：定义把一条边分为几个部分

• 目的：让细分更加平滑

• 切分的方法：

  • equal_Spacing

    • 把一条边等分成设定的段数

    

• fractional_even_spacing

  • 向上取最近的偶数

  • 最小值是2

  • 会把周长分为n-2的等长部分、以及两端不等长的部分，两端部分和小数有关

    

• fractional_odd_spacing

  • 向上取最近的奇数

  • 最小值是1

  • 会把周长分为n-2的等长部分、以及两端不等长的部分

    

Inner Tessellation Factor

• 定义内部的三角形/矩形怎么画

• 三角形

  • 左图将三条边三等分，然后从一个端点开始，取邻近的两个切分点做延长线（垂线），两者的交点就是新三角形的一个端点
  • 超过三等分是在三等分步骤之后，内部三角形的每个边的等分点做延长线，继续迭代

  

• 矩形

  • 与三角形类似，做延长线，交点，直到没有交点或者交于重心一个点

  

shader参考

曲面细分基础

注意：URP中UNITY_domain、UNITY_partitioning等宏要去掉UNITY前缀

//曲面细分Demo1
Shader "Unlit/TessShader"
{
    Properties
    {
        _TessellationUniform("TessellationUniform",Range(1,64)) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100
        Pass
        {
            CGPROGRAM
            //定义2个函数 hull domain
            #pragma hull hullProgram
            #pragma domain ds
           
            #pragma vertex tessvert
            #pragma fragment frag

            #include "UnityCG.cginc"
            //引入曲面细分的头文件
            #include "Tessellation.cginc" 

            #pragma target 5.0
            
            struct VertexInput
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float3 normal : NORMAL;
                float4 tangent : TANGENT;
            };

            struct VertexOutput
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
                float3 normal : NORMAL;
                float4 tangent : TANGENT;
            };

            VertexOutput vert (VertexInput v)
            //这个函数应用在domain函数中，用来空间转换的函数
            {
                VertexOutput o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.tangent = v.tangent;
                o.normal = v.normal;
                return o;
            }

            //有些硬件不支持曲面细分着色器，定义了该宏就能够在不支持的硬件上不会变粉，也不会报错
            #ifdef UNITY_CAN_COMPILE_TESSELLATION
                //顶点着色器结构的定义
                struct TessVertex{
                    float4 vertex : INTERNALTESSPOS;
                    float3 normal : NORMAL;
                    float4 tangent : TANGENT;
                    float2 uv : TEXCOORD0;
                };

                struct OutputPatchConstant { 
                    //不同的图元，该结构会有所不同
                    //该部分用于Hull Shader里面
                    //定义了patch的属性
                    //Tessellation Factor和Inner Tessellation Factor
                    float edge[3] : SV_TESSFACTOR;
                    float inside  : SV_INSIDETESSFACTOR;
                };

                TessVertex tessvert (VertexInput v){
                    //顶点着色器函数
                    TessVertex o;
                    o.vertex  = v.vertex;
                    o.normal  = v.normal;
                    o.tangent = v.tangent;
                    o.uv      = v.uv;
                    return o;
                }

                float _TessellationUniform;
                OutputPatchConstant hsconst (InputPatch<TessVertex,3> patch){
                    //定义曲面细分的参数
                    OutputPatchConstant o;
                    o.edge[0] = _TessellationUniform;
                    o.edge[1] = _TessellationUniform;
                    o.edge[2] = _TessellationUniform;
                    o.inside  = _TessellationUniform;
                    return o;
                }

                [UNITY_domain("tri")]//确定图元，quad,triangle等
                [UNITY_partitioning("fractional_odd")]//拆分edge的规则，equal_spacing,fractional_odd,fractional_even
                [UNITY_outputtopology("triangle_cw")]
                [UNITY_patchconstantfunc("hsconst")]//一个patch一共有三个点，但是这三个点都共用这个函数
                [UNITY_outputcontrolpoints(3)]      //不同的图元会对应不同的控制点
              
                TessVertex hullProgram (InputPatch<TessVertex,3> patch,uint id : SV_OutputControlPointID){
                    //定义hullshaderV函数
                    return patch[id];
                }

                [UNITY_domain("tri")]//同样需要定义图元
                VertexOutput ds (OutputPatchConstant tessFactors, const OutputPatch<TessVertex,3>patch,float3 bary :SV_DOMAINLOCATION)
                //bary:重心坐标
                {
                    VertexInput v;
                    v.vertex = patch[0].vertex*bary.x + patch[1].vertex*bary.y + patch[2].vertex*bary.z;
			        v.tangent = patch[0].tangent*bary.x + patch[1].tangent*bary.y + patch[2].tangent*bary.z;
			        v.normal = patch[0].normal*bary.x + patch[1].normal*bary.y + patch[2].normal*bary.z;
			        v.uv = patch[0].uv*bary.x + patch[1].uv*bary.y + patch[2].uv*bary.z;

                    VertexOutput o = vert (v);
                    return o;
                }
            #endif

            float4 frag (VertexOutput i) : SV_Target
            {

                return float4(1.0,1.0,1.0,1.0);
            }
            ENDCG
        }
    }
    Fallback "Diffuse"
}

结合置换贴图

//曲面细分Demo2：与置换贴图结合使用
Shader "Unlit/Tess_Diss_Shader"
{
    Properties
    {
        _MainTex("MainTex",2D) = "white"{}
        _DisplacementMap("_DisplacementMap",2D)="gray"{}
        _DisplacementStrength("DisplacementStrength",Range(0,1)) = 0
        _Smoothness("Smoothness",Range(0,5))=0.5
        _TessellationUniform("TessellationUniform",Range(1,64)) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" 
               "LightMode"="ForwardBase"}
        LOD 100
        Pass
        {
            CGPROGRAM
            //定义2个函数 hull domain
            #pragma hull hullProgram
            #pragma domain ds
           
            #pragma vertex tessvert
            #pragma fragment frag

            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            //引入曲面细分的头文件
            #include "Tessellation.cginc" 

            #pragma target 5.0
            float _TessellationUniform;
            sampler2D _MainTex;
            float4 _MainTex_ST;

            sampler2D _DisplacementMap;
            float4 _DisplacementMap_ST;
            float _DisplacementStrength;
            float _Smoothness;

            struct VertexInput
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float3 normal : NORMAL;
                float4 tangent : TANGENT;
            };

            struct VertexOutput
            {
                float2 uv : TEXCOORD0;
                float4 pos : SV_POSITION;
                float4 worldPos:TEXCOORD1;
                half3 tspace0 :TEXCOORD2;
                half3 tspace1 :TEXCOORD3;
                half3 tspace2 :TEXCOORD4;
            };

            VertexOutput vert (VertexInput v)
            //这个函数应用在domain函数中，用来空间转换的函数
            //通过置换贴图的深度，来把顶点沿着它的法线方向进行移动，以此来对mesh进行形变
            {
                VertexOutput o;
                o.uv = TRANSFORM_TEX(v.uv,_MainTex);
                //Displacement
                //由于并不是在Fragnent shader中读取图片，GPU无法获取mipmap信息，因此需要使用tex2Dlod来读取图片，使用第四坐标作为mipmap的level，这里取了0
                float Displacement = tex2Dlod(_DisplacementMap,float4(o.uv.xy,0.0,0.0)).g;
                Displacement = (Displacement-0.5)*_DisplacementStrength;
                v.normal = normalize(v.normal);
                v.vertex.xyz += v.normal * Displacement;

                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);

                //计算切线空间转换矩阵
                half3 vNormal = UnityObjectToWorldNormal(v.normal);
                half3 vTangent = UnityObjectToWorldDir(v.tangent.xyz);
                //compute bitangent from cross product of normal and tangent
                half tangentSign = v.tangent.w * unity_WorldTransformParams.w;
                half3 vBitangent = cross(vNormal,vTangent)*tangentSign;
                //output the tangent space matrix
                o.tspace0 = half3(vTangent.x,vBitangent.x,vNormal.x);
                o.tspace1 = half3(vTangent.y,vBitangent.y,vNormal.y);
                o.tspace2 = half3(vTangent.z,vBitangent.z,vNormal.z);
                return o;
            }

            //有些硬件不支持曲面细分着色器，定义了该宏就能够在不支持的硬件上不会变粉，也不会报错
            #ifdef UNITY_CAN_COMPILE_TESSELLATION
                //顶点着色器结构的定义
                struct TessVertex{
                    float4 vertex : INTERNALTESSPOS;
                    float3 normal : NORMAL;
                    float4 tangent : TANGENT;
                    float2 uv : TEXCOORD0;
                };

                struct OutputPatchConstant { 
                    //不同的图元，该结构会有所不同
                    //该部分用于Hull Shader里面
                    //定义了patch的属性
                    //Tessellation Factor和Inner Tessellation Factor
                    float edge[3] : SV_TESSFACTOR;
                    float inside  : SV_INSIDETESSFACTOR;
                };

                TessVertex tessvert (VertexInput v){
                    //顶点着色器函数
                    TessVertex o;
                    o.vertex  = v.vertex;
                    o.normal  = v.normal;
                    o.tangent = v.tangent;
                    o.uv      = v.uv;
                    return o;
                }

                //float _TessellationUniform;
                OutputPatchConstant hsconst (InputPatch<TessVertex,3> patch){
                    //定义曲面细分的参数
                    OutputPatchConstant o;
                    o.edge[0] = _TessellationUniform;
                    o.edge[1] = _TessellationUniform;
                    o.edge[2] = _TessellationUniform;
                    o.inside  = _TessellationUniform;
                    return o;
                }

                [UNITY_domain("tri")]//确定图元，quad,triangle等
                [UNITY_partitioning("fractional_odd")]//拆分edge的规则，equal_spacing,fractional_odd,fractional_even
                [UNITY_outputtopology("triangle_cw")]
                [UNITY_patchconstantfunc("hsconst")]//一个patch一共有三个点，但是这三个点都共用这个函数
                [UNITY_outputcontrolpoints(3)]      //不同的图元会对应不同的控制点
              
                TessVertex hullProgram (InputPatch<TessVertex,3> patch,uint id : SV_OutputControlPointID){
                    //定义hullshaderV函数
                    return patch[id];
                }

                [UNITY_domain("tri")]//同样需要定义图元
                VertexOutput ds (OutputPatchConstant tessFactors, const OutputPatch<TessVertex,3>patch,float3 bary :SV_DOMAINLOCATION)
                //bary:重心坐标
                {
                    VertexInput v;
                    v.vertex = patch[0].vertex*bary.x + patch[1].vertex*bary.y + patch[2].vertex*bary.z;
			        v.tangent = patch[0].tangent*bary.x + patch[1].tangent*bary.y + patch[2].tangent*bary.z;
			        v.normal = patch[0].normal*bary.x + patch[1].normal*bary.y + patch[2].normal*bary.z;
			        v.uv = patch[0].uv*bary.x + patch[1].uv*bary.y + patch[2].uv*bary.z;

                    VertexOutput o = vert (v);
                    return o;
                }
            #endif

            float4 frag (VertexOutput i) : SV_Target
            {
                float3 lightDir =_WorldSpaceLightPos0.xyz;
                float3 tnormal = UnpackNormal (tex2D (_DisplacementMap, i.uv));
                half3 worldNormal;
                worldNormal.x=dot(i.tspace0,tnormal);
                worldNormal.y= dot (i.tspace1, tnormal);
                worldNormal.z=dot (i.tspace2, tnormal);
                float3 albedo=tex2D (_MainTex, i.uv). rgb;
                float3 lightColor = _LightColor0.rgb;
                float3 diffuse = albedo * lightColor * DotClamped(lightDir,worldNormal);
                float3 viewDir = normalize (_WorldSpaceCameraPos. xyz-i. worldPos. xyz);
                float3 halfVector = normalize(lightDir + viewDir);
                float3 specular = albedo * pow (DotClamped (halfVector, worldNormal), _Smoothness * 100);
                float3 result = specular + diffuse;
                return float4(result, 1.0);
            }
            ENDCG
        }
    }
    Fallback "Diffuse"
}

几何着色器-Geometry shader （GS）

应用

• 几何动画

  

• 草地等效果（与曲面细分结合）
  

  

GS的输入和输出

• 输入

  • 输入为单个图元（三角形、矩形、线等等）
  • 根据不同的图元，shader中不同的顶点数量

• 输出

• 输出也为图元（一个或者多个）
• 同时还要定义输出的最大顶点数
• 输出的图元需要自己一个点一个点的自己去构建，顺序很重要（这个着色器最主要的功能：自己构建图元）

• 流程

  • 输入输出结构
  • 定义最大输出定点数
  • 几何着色器

参考资料

• Unity3D Shader系列之几何着色器基础
• Geometry Shader学习笔记
• 放牛的星星大佬翻译的catlike-曲面细分着色器
• urp-shader-code
• 大佬笔记
  • https://www.yuque.com/sugelameiyoudi-jadcc/okgm7e/xyx5h5#m3WTu
  • https://www.yuque.com/u21083280/nc24zq/ih6lnd?#Sp6dq
  • https://www.yuque.com/wuyan-popj0/xkh798/bqehsptso1aosebv#ofqRA
  • https://www.yuque.com/xinghen-q7o8z/ru547n/cfiu2o
  • https://www.yuque.com/zohar-jpfbj/tiacmz/enuk60?
  • https://blog.csdn.net/wrl780143706/article/details/119787014

作业

大伙喜欢的草地

https://zhuanlan.zhihu.com/p/433385999
https://roystan.net/articles/grass-shader/
https://www.youtube.com/watch?v=MeyW_aYE82s
https://zhuanlan.zhihu.com/p/521190501

• 草的生成
• 草随风摆动
• 草根据相机距离不同细分策略
• 草与物体交互

遇到的问题与解决

• m1芯片不支持几何着色器，苹果Metal不支持，换openGL也不行，貌似芯片就不支持。给出的原因是几何着色器比较耗性能，没打算支持。掏出windows电脑继续练习
  • 补充：因为有了compute shader这个上位替代
• URP写入shadowmap只需要定义ShadowCaster这个pass即可
• 接收阴影需要用TransformWorldToShadowCoord读取shadowmap纹理坐标，再传入相关api获取。还需要开启阴影相关feature

shader代码

Shader "Roystan/Grass"
{
    Properties
    {
        _TopColor("草尖颜色", Color) = (1,1,1,1)
		_BottomColor("草根颜色", Color) = (1,1,1,1)
		_TranslucentGain("Translucent Gain", Range(0,1)) = 0.5
    	_BladeWidth("草宽度", Float) = 0.05
    	_BladeWidthRandom("草随机叠加宽度", Float) = 0.5
    	_BladeHeight("草高度", Float) = 0.5
    	_BladeHeightRandom("草随机叠加高度", Float) = 0.3
    	_BendRotationRandom("草随机旋转", Range(0, 1)) = 0.2
    	_BladeForward("草向前弯曲幅度", Float) = 0.38
    	_BladeCurve("草弯曲曲率", Range(1, 4)) = 2
    	_TessellationEdgeLength("草皮离相机距离影响细分因子", Range(1, 64)) = 1
    	_WindDistortionMap("风扰动贴图", 2D) = "white" {}
    	_WindFrequency("风吹频率", Vector) = (0.05, 0.05, 0, 0)
    	_WindStrength("风强度", Float) = 1
    	_InteractivePos("交互物体位置", Vector) = (0,0,0,0)
    	_InteractiveRadius("交互影响半径", Float) = 1
    	_InteractiveStrength("交互影响强度", Float) = 1
    }

	HLSLINCLUDE
	#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
	#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

	CBUFFER_START(UnityPerMaterial)
	float4 _TopColor;
	float4 _BottomColor;
	float _TranslucentGain;
	float _BendRotationRandom;
	float _BladeWidth;
	float _BladeWidthRandom;
	float _BladeHeight;
	float _BladeHeightRandom;
	float _BladeForward;
	float _BladeCurve;
	float4 _WindDistortionMap_ST;
	float4 _WindFrequency;
	float _WindStrength;
	float _TessellationEdgeLength;
	float4 _InteractivePos;
	float _InteractiveRadius;
	float _InteractiveStrength;
	CBUFFER_END

	TEXTURE2D(_WindDistortionMap);SAMPLER(sampler_WindDistortionMap);

	// Simple noise function, sourced from http://answers.unity.com/answers/624136/view.html
	// Extended discussion on this function can be found at the following link:
	// https://forum.unity.com/threads/am-i-over-complicating-this-random-function.454887/#post-2949326
	// Returns a number in the 0...1 range.
	//从一个三维输入生成一个随机数
	float rand(float3 co)
	{
		return frac(sin(dot(co.xyz, float3(12.9898, 78.233, 53.539))) * 43758.5453);
	}

	// Construct a rotation matrix that rotates around the provided axis, sourced from:
	// https://gist.github.com/keijiro/ee439d5e7388f3aafc5296005c8c3f33
	//接收一个角度（弧度制）并返回一个围绕提供轴旋转的矩阵
	//应该是使用了罗德里格斯公式
	float3x3 AngleAxis3x3(float angle, float3 axis)
	{
		float c, s;
		sincos(angle, s, c);

		float t = 1 - c;
		float x = axis.x;
		float y = axis.y;
		float z = axis.z;

		return float3x3(
			t * x * x + c, t * x * y - s * z, t * x * z + s * y,
			t * x * y + s * z, t * y * y + c, t * y * z - s * x,
			t * x * z - s * y, t * y * z + s * x, t * z * z + c
			);
	}

	struct vertexInput
	{
		float4 vertex : POSITION;
		float3 normal : NORMAL;
		float4 tangent : TANGENT;
	};

	struct vertexOutput
	{
		float4 vertex : SV_POSITION;
		float3 normal : NORMAL;
		float4 tangent : TANGENT;
	};

	struct TessellationFactors 
	{
		float edge[3] : SV_TessFactor;
		float inside : SV_InsideTessFactor;
	};
	
	// 用于几何着色器输出
	struct geometryOutput
	{
		float4 pos : SV_POSITION;
		float2 uv : TEXCOORD0;
		float3 normal : NORMAL;
		float4 shadowCoord : TEXCOORD1;
	};

	//===============曲面细分相关===================
	vertexOutput tessVert(vertexInput v)
	{
		vertexOutput o;
		// Note that the vertex is NOT transformed to clip
		// space here; this is done in the grass geometry shader.
		o.vertex = v.vertex;
		o.normal = v.normal;
		o.tangent = v.tangent;
		return o;
	}

	// 根据三角形离相机位置计算细分程度
	// 1. 通过P0,P1的获取他们的世界空间下的中点G。
	// 2. 然后获得G点到相机的距离，也就是类深度值了。
	// 3. 然后通过影响深度来修改曲分因子。
	// 4. 为了保证屏幕高度/近远的裁剪面距离比，加入_ScreenParams.y。
	// 这样其实过远或者过近还是有点问题，最好是引入LOD分层
	float GetTessSegments(float3 vertex0OS, float3 vertex1OS)
	{
		float3 p0 = mul(unity_ObjectToWorld, float4(vertex0OS, 1)).xyz;
		float3 p1 = mul(unity_ObjectToWorld, float4(vertex1OS, 1)).xyz;
		float edgeLength = distance(p0, p1);

		float3 edgeCenter = (p0 + p1) * 0.5;
		float viewDistance = distance(edgeCenter, _WorldSpaceCameraPos);

		return edgeLength * _ScreenParams.y/ (_TessellationEdgeLength * viewDistance);
	}

	TessellationFactors patchConstantFunction (InputPatch<vertexInput, 3> patch)
	{
		TessellationFactors f;
		float tessSegments = GetTessSegments(patch[0].vertex, patch[1].vertex);
		f.edge[0] = tessSegments;
		f.edge[1] = tessSegments;
		f.edge[2] = tessSegments;
		f.inside = tessSegments;
		return f;
	}

	[domain("tri")]
	[outputcontrolpoints(3)]
	[outputtopology("triangle_cw")]
	[partitioning("integer")]
	[patchconstantfunc("patchConstantFunction")]
	vertexInput hull (InputPatch<vertexInput, 3> patch, uint id : SV_OutputControlPointID)
	{
		return patch[id];
	}

	[domain("tri")]
	vertexOutput domain(TessellationFactors factors, OutputPatch<vertexInput, 3> patch, float3 barycentricCoordinates : SV_DomainLocation)
	{
		vertexInput v;

		#define MY_DOMAIN_PROGRAM_INTERPOLATE(fieldName) v.fieldName = \
			patch[0].fieldName * barycentricCoordinates.x + \
			patch[1].fieldName * barycentricCoordinates.y + \
			patch[2].fieldName * barycentricCoordinates.z;

		MY_DOMAIN_PROGRAM_INTERPOLATE(vertex)
		MY_DOMAIN_PROGRAM_INTERPOLATE(normal)
		MY_DOMAIN_PROGRAM_INTERPOLATE(tangent)

		return tessVert(v);
	}

	//===============几何相关===================
	// 计算与角色交互相关的数据
	float3 GetInteractiveData(float3 pos)
	{
		float3 interactWS = TransformWorldToObject(_InteractivePos);
		float3 dis = distance(interactWS, pos);
		float radius = 1-saturate(dis/_InteractiveRadius);
		float3 sphereDisp = float3(pos.x-interactWS.x, pos.z-interactWS.z, 0);
		return float3(sphereDisp.xy, radius * _InteractiveStrength);
	}
	
	// 生产草叶数据
	geometryOutput VertexOutput(float3 pos, float2 uv, float3 normalOS)
	{
		geometryOutput o = (geometryOutput)0;
		o.uv = uv;
		o.pos = TransformObjectToHClip(pos);
		float3 worldPos = TransformObjectToWorld(pos);
		o.shadowCoord = TransformWorldToShadowCoord(worldPos);
		o.normal = TransformObjectToWorldNormal(normalOS);

		// 这块不太好看，后续重构下
		#if UNITY_PASS_SHADOWCASTER
		worldPos = ApplyShadowBias(worldPos, o.normal, _LightDirection);
		o.pos = TransformWorldToHClip(worldPos);
		#endif
		
		return o;
	}
	geometryOutput GenerateGrassVertex(float3 vertexPosition, float width, float height, float forward, float2 uv, float3x3 transformMatrix)
	{
		float3 tangentPoint = float3(width, forward, height);

		// 法线,当草叶曲率量设置为1时，草叶在切线空间中都面向同一个方向：向后的y轴
		// 当草叶的曲率大于1时，每个顶点的切线Z位置将被传递到GenerateGrassVertex函数中的前量所抵消
		float3 tangentNormal = float3(0, -1, forward);
		float3 normalOS = mul(transformMatrix, tangentNormal);
		
		float3 localPosition = vertexPosition + mul(transformMatrix, tangentPoint);
		return VertexOutput(localPosition, uv, normalOS);
	}

	// 草叶要分成几段
	#define BLADE_SEGMENTS 5
	// 几何着色器处理函数
	// 限制每个图元最多生成顶点数（可小于）
	[maxvertexcount(BLADE_SEGMENTS * 2 + 1)]
	void geo(triangle vertexOutput IN[3], inout TriangleStream<geometryOutput> triStream)
	{
		
		float3 pos = IN[0].vertex;
		float3 vNormal = IN[0].normal;
		float4 vTangent = IN[0].tangent;
		float3 vBinormal = cross(vNormal, vTangent) * vTangent.w;

		//构建TBN矩阵
		float3x3 tangentToLocal = float3x3(
			vTangent.x, vBinormal.x, vNormal.x,
			vTangent.y, vBinormal.y, vNormal.y,
			vTangent.z, vBinormal.z, vNormal.z
		);

		// 整体旋转矩阵(pos作为随机种子)
		float3x3 facingRotationMatrix = AngleAxis3x3(rand(pos) * PI, float3(0, 0, 1));

		//创建一个新的矩阵来沿让它着它的x轴旋转，以达到模拟弯曲的操作，0.5PI是为了得到0~90°
		float3x3 bendRotationMatrix = AngleAxis3x3(rand(pos.zzx) * _BendRotationRandom * PI * 0.5, float3(-1, 0, 0));

		// 用pos来构建uv坐标的好处是：如果多个mesh使用这个shader，会感觉像它们受到同一种风的作用
		float2 uv = pos.xz * _WindDistortionMap_ST.xy + _WindDistortionMap_ST.zw + _WindFrequency * _Time.y;
		float2 windSample = (SAMPLE_TEXTURE2D_LOD(_WindDistortionMap, sampler_WindDistortionMap, uv, 0).xy * 2 - 1) * _WindStrength;
		float3 wind = normalize(float3(windSample.x, windSample.y, 0));
		float3x3 windRotationMatrix = AngleAxis3x3(windSample * PI, wind);

		// 与交互物体产生的偏移
		float3 interactData = GetInteractiveData(pos);
		float3x3 interactRotationMatrix = AngleAxis3x3(interactData.z * PI, normalize(float3(interactData.x, interactData.y, 0)));
		

		// 底部点不需要弯曲和风吹拂效果
		float3x3 transformationMatrixFacing = mul(tangentToLocal, facingRotationMatrix);
		float3x3 transformationMatrix = mul(mul(mul(mul(tangentToLocal, facingRotationMatrix), bendRotationMatrix), windRotationMatrix), interactRotationMatrix);
		
		geometryOutput o;
		
		
		// 控制草的高度宽度
		float height = (rand(pos.zyx) * 2 - 1) * _BladeHeightRandom + _BladeHeight;
		float width = (rand(pos.xzy) * 2 - 1) * _BladeWidthRandom + _BladeWidth;

		// 为草叶拆分三角形，更加真实
		//   -
		//  - -
		// -   -
		//-     -
		float forward = rand(pos.yyz) * _BladeForward;
		
		for (int i = 0; i < BLADE_SEGMENTS; i++)
		{
			float t = i / (float)BLADE_SEGMENTS;
			float segmentHeight = height * t;
			float segmentWidth = width * (1 - t);
			float segmentForward = pow(t, _BladeCurve) * forward;
			// 只有底部两个顶点需要固定
			float3x3 transformMatrix = i == 0 ? transformationMatrixFacing : transformationMatrix;
			triStream.Append(GenerateGrassVertex(pos, segmentWidth, segmentHeight, segmentForward, float2(0, t), transformMatrix));
			triStream.Append(GenerateGrassVertex(pos, -segmentWidth, segmentHeight, segmentForward, float2(1, t), transformMatrix));
		}
		
		triStream.Append(GenerateGrassVertex(pos, 0, height, forward, float2(0.5, 1), transformationMatrix));
	}

	
	ENDHLSL

    SubShader
    {
		Cull Off

        Pass
        {
			Tags
			{
				"RenderType" = "Opaque"
				"RenderPipeline"="UniversalPipeline"
			}

            HLSLPROGRAM
            #pragma vertex tessVert
            #pragma geometry geo
            #pragma hull hull
            #pragma domain domain
            #pragma fragment frag
			#pragma target 4.6

            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
            
			float4 frag (geometryOutput i, half facing : VFACE) : SV_Target
            {
				float3 normal = facing > 0 ? i.normal : -i.normal;
            	Light light = GetMainLight(i.shadowCoord);
            	float3 lightDir = TransformObjectToWorld(light.direction);
            	float NdotL = saturate(saturate(dot(normal, lightDir)) + _TranslucentGain);
            	
            	half3 ambient = SampleSH(normal);
            	float3 lightIntensity = NdotL * light.color * ambient * light.shadowAttenuation;

            	float4 finalColor = lerp(_BottomColor, _TopColor * float4(lightIntensity, 1), i.uv.y);

            	return finalColor;
            }
            ENDHLSL
        }
    	
    	Pass
    	{
    		Tags{ "LightMode"="ShadowCaster"}
    		ColorMask 0
    		
    		HLSLPROGRAM
    		#pragma vertex tessVert
            #pragma geometry geo
            #pragma hull hull
            #pragma domain domain
            #pragma fragment frag
			#pragma target 4.6
    		
    		float4 frag (geometryOutput i) : SV_Target
            {	
				return 0;
            }
    		ENDHLSL
        }
    }
}

后续实现

• 可交互雪地，may佬视频
• 利用集合着色器制作溶解特效的粒子
  
• Keijiro大神的瞬移特效