TA Shader基础

微笑小星

于 2023-11-11 13:50:45 发布

阅读量551

点赞数 21

分类专栏： shader 文章标签： shader

本文链接：https://blog.csdn.net/tianjuewudi/article/details/134347490

版权

shader 专栏收录该内容

3 篇文章 1 订阅

订阅专栏

渲染管线

概念：GPU绘制物体的时候，标准的，流水线一样的操作

游戏引擎如何绘制物体：CPU提供绘制数据（顶点数据，纹理贴图等）给GPU，配置渲染管线（装载Shader代码到GPU，配置一次称为一次SetPassCall），并对GPU下命令（DrawCall）绘制。原来的顶点数据需要经过三次矩阵的变换。分别是映射到世界坐标，以摄像机为中心的坐标，投影坐标

纹理坐标：当一个模型建好之后，我们需要给模型上色，上色的过程相当于在一张白纸上面画画，只不过是这张白纸包住了模型，模型顶点在白纸上的坐标就是纹理坐标。

材质其实是配置shader的配置文件，CPU从材质中读取shader数据，把shader程序装载进GPU

顶点数据

模型有一个个三角形面构成，一个面包含三个顶点。
顶点数据包含模型坐标（相对于模型原点），纹理坐标，法线向量，切线向量。

流程

顶点初始化->顶点shader（编程）->Tellellation曲面化->几何shader->裁剪，投影->三角形遍历->片元着色shader（编程）->输出2D图像

顶点初始化：CPU提供顶点数据给GPU,顶点数据包括在模型中的位置，UV纹理坐标，法线，切线等。Unity定义一些装固定数据的"盒子"（SV_XXXX），顶点shader从中拿数据，其他没有固定数据的"盒子"用户可以自由使用

顶点Shader：

形状变换（可选）你通过代码，改变顶点的模型坐标
坐标变换（绘制到准确位置），经过三次坐标变换，映射到2D平面
数据传递（由编程者决定内容），把数据传回渲染管线，有固定的数据盒子

片元着色shader：
片元是涂色的最小单位，可以看成像素点。每个片元的数据通过顶点数据插值得来，可以引入光照计算。

Unity Shader模板

创建一个unlit Shader，它是一个基础模板，可以开发任意效果：

Shader "Unlit/Shader"
{
    // 属性列表，可以在编辑器中赋值，用户传递的，不能在shader中修改，在所有着色器可以访问
    Properties
    {
        // 变量名（"显示名字",类型）= 默认值
        _MainTex ("Texture", 2D) = "white" {}
    } 

    SubShader
    {
        Tags { "RenderType"="Opaque" }
        // 细节距离，离得远不用细节
        LOD 100
        // 一个Pass是一个完整的渲染管线绘制
        Pass
        {
            CGPROGRAM    // CG代码的开始
            #pragma vertex vert   //预编译，告诉编译器顶点代码在哪
            #pragma fragment frag //预编译，告诉编译器片元着色代码在哪
            // make fog work
            #pragma multi_compile_fog
            // Unity封装的Shader API
            #include "UnityCG.cginc"
 
            struct appdata   // shader中需要使用的数据，Unity定义了一些语义描述来取对应的数据，POSITION，TEXCOORD0对应的是一个个盒子数据，这些数据会先进入顶点shader，可以直接获取
            {
                float4 vertex : POSITION;  // 模型坐标，可改
                float2 uv : TEXCOORD0;     // 开始时候存的纹理坐标，可改
            };

            struct v2f  // 给片元shader使用的数据，经过顶点shader计算后得到
            {
                float2 uv : TEXCOORD0;
                UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;
            };
            // 定义用户的属性变量的数据变量，刚好对应2D中的两种数据类型
            sampler2D _MainTex;   // 图片
            float4 _MainTex_ST;   // Tilling,offset四个分量
            // 顶点shader
            v2f vert (appdata v)
            {
                v2f o;
                // 坐标空间的转换，直接转到投影空间
                o.vertex = UnityObjectToClipPos(v.vertex);
                // 纹理坐标叠加上Tilling和offset
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                UNITY_TRANSFER_FOG(o,o.vertex);
                // 返回数据给渲染管线
                return o;
            }

            // 片元着色shader，着色调用次数远远大于顶点shader调用次数
            // 着色好了放到SV_Target
            // 这个v2f的参数并不等于顶点里面返回的v2f，而是插值后每个片元的v2f
            fixed4 frag (v2f i) : SV_Target
            {
                // sample the texture
                fixed4 col = tex2D(_MainTex, i.uv);
                // apply fog
                UNITY_APPLY_FOG(i.fogCoord, col);
                return col;
            }
            ENDCG
        }
    }
}

摄像机如何显示颜色

摄像机看见的颜色=物体本身的发光+反射环境中所有的光
除了太阳，灯泡等物体，大多数是不会自发光的，只会反射光，物体的颜色是因为反射了特定的颜色的光，吸收了其他颜色的光得到的。
自然界的光照是一个非常多次叠加的效果，非常复杂，因此需要简化：不考虑二次反射的光，并且不考虑其他物体的遮挡，但是考虑自己的遮挡。公式变为：
摄像机看见的颜色=物体本身的发光+本色*(直接光照反射+一次反射光+考虑自己的遮挡)+环境光

反射分为镜面反射和漫反射，而环境直接光照和一次反射光可以分为这两种类型，具体类型由材质决定。

每个光都可以用红，绿，蓝，强度表示，例如：
白光(1,1,1,1)
红光(1,0,0,1)
光照的时候，物体的颜色=本色光照
白光照在红物体上：(1,1,1,1)(1,0,0,1)=(1,0,0,1)=红色
物体本色在建模的时候就决定好了，渲染的好的关键是调节反射
常用的终极简化：

颜色=本色，休闲小游戏常用，对光照无要求
颜色=本色*漫反射，移动端常用（兰伯特，半兰伯特）

法线与光照计算

光照计算研究方向有两种：

基于经验模型（不要求逼真，用于卡通渲染）：
漫反射有兰伯特，半兰伯特
镜面反射有冯高光，布林冯高光
基于物理PBR（遵循物理定律，能量守恒，模拟真实世界，效果逼真）

法线用于反射，是光照计算的关键。每个片元的法线都可以由顶点法线插值得到。

如何增强模型细节？
方案一：做高模型（面数多，计算量大）
方案二：建一个高模型，只导出法线贴图，但是模型依旧用低模型，但是法线到高模的法线贴图中取，能做出同样的光暗细节。

一个贴图每个点都有对应的RGBA（颜色分量），法线向量可以存储在颜色分量中得到法线贴图。每个法线都是一个标准化向量，通过将三维坐标映射到0到1的范围内通过颜色分量的前三维存储。取出同理，映射和反向映射方法：
(-1,1)*0.5+0.5–>(0,1)
(0,1)*2-1–>(-1,1)

我们也可以只存储x,y，z通过标准化向量来求解得到，可以压缩存储空间。

逐顶点和逐像素光照

这部分计算发生在片元着色shader

逐像素：根据顶点的数据给每个片元插值计算法线，纹理坐标，坐标。然后将这些像素逐个计算反射。这部分计算都在片元着色，这是按照片元的法线计算的。

逐顶点：在顶点shader时候，我们算好顶点的光照颜色（直射光+反射光+环境光），然后通过插值得到每个片元的光照颜色，在片元着色shader的时候只需要将对应纹理的 本色插值的光照 就可以了，不用每个像素使用法线的计算光照了。计算量远远小于逐像素，是移动平台主要采用的方式，但效果可能不能那么细腻。

逐顶点光照：

Shader "Bycw/VertexLight"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode"="ForwardBase" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            #pragma multi_compile_fog

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

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

            struct v2f
            {
                float2 uv : TEXCOORD0;
                UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;
                // 存放片元光照
                float4 allLight : TEXCOORD1;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                UNITY_TRANSFER_FOG(o,o.vertex);

                // 计算我们的光照
                float3 N = normalize(UnityObjectToWorldNormal(v.normal));
                float3 L = normalize(_WorldSpaceLightPos0);
                float halfLam = dot(L, N) * 0.5 + 0.5;
                float3 halfLamLight = halfLam * _LightColor0.rgb;
                // 把光照传递给片元
                o.allLight = float4(halfLamLight, 1);
                // end

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {               
                fixed4 col = tex2D(_MainTex, i.uv);
                //片元直接本色乘光照
                col *= i.allLight;

                // apply fog
                UNITY_APPLY_FOG(i.fogCoord, col);
                return col;
            }
            ENDCG
        }
    }
}

逐片元请看下一小节。

兰伯特漫反射模型

漫反射，是指光照射在粗糙表明向各个方向反射的现象，在这个模型中，向各个方向反射的光强度一致，反射光的强度等于反射光的方向和法线的点乘。因此这个值是0到1的一个范围（负数置0），1代表入射光强度。也就是说光的入射方向如果正好在法线上，那么漫反射的强度等于光照强度。这也是符合直觉的，在一个平面上，靠近光源的点是最亮的，因为光源刚好在法线上。

为了防止点乘之后的值为负，可以把这个点乘后的值乘0.5，再加0.5，这样就能把范围映射到0到1，这就是半兰伯特反射模型。

这个例子是逐片元光照，对应上一小节的逐顶点：

Shader "Unlit/Shader"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        // 配置模式
        Tags { "RenderType"="Opaque" "LightMode"="ForwardBase"}
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"
            // 使用光照头文件
            #include "Lighting.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                // 拿到模型的法线
                float3 normal: NORMAL;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
                //定义世界坐标系下的法线，因为这里是逐像素（片元），要计算好后传给片元着色shader，如果是逐顶点，就传插值的光照就行
                float3 wNormal: TEXCOORD1; 
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                o.wNormal = UnityObjectToWorldNormal(v.normal);

                return o;
            }
 
            fixed4 frag (v2f i) : SV_Target
            {
                // 光照方向的标准化向量
                float3 L = normalize(_WorldSpaceLightPos0);
                // 法线向量
                float3 N = i.wNornal;
                // 半兰伯特公式
                float halfLam = dot(L,N) * 0.5 + 0.5
                // 反射光计算
                float3 diff = halfLam * _LightColor0.rgb;
                // 转换单位到4维向量
                fixed4 diffColor = fixed4(diffLight.rgb,1);
                fixed4 col = tex2D(_MainTex, i.uv);
                // 本色 * 光照
                return col * diffColor;
            }
            ENDCG
        }
    }
}

冯高光和布林冯高光经验模型

Phong镜面反射模型：
镜面反射在物体表面绝对光滑的情况下，只往法线另一侧相同的夹角反射光线。但是一般没有绝对光滑的物体，因此也会往其他方向反射光线，只是强度会随着偏移反射角而减弱。假设我们定义物体的光滑度为N，标准反射角向量为R，反射点到摄像机的向量为V，则有：

$反射光强度= (\max(0,Dot(R,V)))^N$

Blin-Phone镜面反射模型：

$反射光强度= (\max(0,Dot(H,N)))^N$

其中，N是法线向量，H是视角向量和光源向量的半角向量。也就是说这个向量平分视角向量和光源入射向量，这个向量越接近法线，则视角接收的反射光越强。

Shader "Bycw/BycwPhong"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        // 属性面板，可以在编辑器中设置
        _Gloss("Gloss", Range(0, 5)) = 1
    }

    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode"="ForwardBase"}
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag


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

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                // 拿到模型法线
                float3 normal: NORMAL;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                // 世界坐标系下法线 
                float3 wNormal: TEXCOORD1;
                // 顶点的世界坐标
                float3 worldPos: TEXCOORD2;

                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            // 属性
            float _Gloss;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                // 世界法线
                o.wNormal = normalize(UnityObjectToWorldNormal(v.normal));
                // 顶点世界坐标
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // 片元到光源的标准化向量
                float3 L = normalize(-_WorldSpaceLightPos0);
                // 法线
                float3 N = normalize(i.wNormal);
                // 反射向量
                float3 R = reflect(L, N);
                // 片元到摄像机的向量
                float3 V = normalize(_WorldSpaceCameraPos - i.worldPos);
                // float _Gloss = 1;

                // Lambert计算光强
                float halfLambert = dot(-L, N) * 0.5 + 0.5;
                float3 halfLight = halfLambert * _LightColor0.rgb;
                // Phong高光计算光强
                float phong = pow(max(0, dot(R, V)), _Gloss); 
                float3 phoneLight = phong * _LightColor0.rgb;
                // 0.3的漫反射，0.7的镜面反射
                float4 allLight = float4(phoneLight.rgb, 1) * 0.3 + float4(halfLight.rgb, 1) * 0.7;
                fixed4 col = tex2D(_MainTex, i.uv);

                return col * allLight;
            }
            ENDCG
        }
    }
}

Blin-Phong高光

Shader "Bycw/BlinPhong"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Gloss("Gloss", Range(0, 5)) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode"="ForwardBase" }
        LOD 100

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

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

            struct v2f
            {
                float3 wNormal: TEXCOORD1; 
                float2 uv : TEXCOORD0;
                float3 worldPos: TEXCOORD2;

                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float _Gloss;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                
                o.wNormal = normalize(UnityObjectToWorldNormal(v.normal)); 
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 N = i.wNormal;
                float3 V = normalize(_WorldSpaceCameraPos - i.worldPos);
                float3 L = normalize(_WorldSpaceLightPos0);
                // 半角向量
                float3 H = normalize(L + V);
                // Blin-Phony光强度
                float blinPhong = pow(max(0, dot(H, N)), _Gloss);
                float halfLam = dot(L, N) * 0.5 + 0.5;
                float3 blinPhoneLight = _LightColor0.rgb * blinPhong;
                // 半兰伯特光强度
                float3 halfLamLight = _LightColor0.rgb * halfLam;
                // 两者的光照叠加
                float4 allLight = float4(blinPhoneLight, 0.5) + float4(halfLamLight, 0.5);
                // sample the texture
                fixed4 col = tex2D(_MainTex, i.uv);
                return col * allLight;
            }
            ENDCG
        }
    }
}

法线贴图

次时代中法线贴图是标配

Shader "Bycw/BycwNormal"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        // 定义法线贴图
        _NormalTex ("Normal", 2D) = "white" {}
        
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" "LightMode"="ForwardBase"}
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            #pragma multi_compile_fog

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

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

            struct v2f
            {
                float2 uv : TEXCOORD0;
                UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;
                float3 wNormal: TEXCOORD1;
                float3 worldPos: TEXCOORD2;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            // 法线贴图
            sampler2D _NormalTex;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                UNITY_TRANSFER_FOG(o,o.vertex);
                
                // 可以不写这行
                o.wNormal = normalize(UnityObjectToWorldNormal(v.normal));
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 L = normalize(_WorldSpaceLightPos0);
                // float3 N = i.wNormal;
                // 法线向量(0,1)解包到(-1,1)得到对应片元的法线向量
                float3 N = normalize(UnpackNormal(tex2D(_NormalTex, i.uv))); 
                float3 V = normalize(_WorldSpaceCameraPos - i.worldPos);
                float3 H = normalize(V + L);

                float _Gloss = 4;
                float blinPhong = pow(max(0, dot(H, N)), _Gloss);
                float halfLam = dot(L, N) * 0.5 + 0.5;
                float3 blinPhoneLight = _LightColor0.rgb * blinPhong;
                float3 halfLamLight = _LightColor0.rgb * halfLam;
                // 镜面反射+漫反射+环境光强度
                float4 allLight = float4(blinPhoneLight, 0.5) + float4(halfLamLight, 0.5) + UNITY_LIGHTMODEL_AMBIENT;

                // sample the texture
                fixed4 col = tex2D(_MainTex, i.uv);
                col *= allLight;

                // apply fog
                UNITY_APPLY_FOG(i.fogCoord, col);
                return col;
            }
            ENDCG
        }
    }
}

PBR次时代美术工作流

PBR(Physically Based Rendering)是基于物理原理来模拟计算光的反射。算法是成熟的，我们不直接实现其原理，而是调节参数。

PBR有两种工作流，可以相互转换：

金属与粗糙度工作流：主要元素是颜色贴图，金属度，粗糙度，法线贴图。金属度是模拟光线反射的强度的贴图，例如皮肤是0，盔甲是1。粗糙度是模拟漫反射的贴图，更多细节。这个工作流的优点是更容易创作，各个贴图是分开的，纹理占用内存小（金属和粗糙度贴图是灰度图），更广泛被应用，但是缺点是边缘的伪像更明显，尤其是分辨率低的时候。
反射与光泽度工作流：接近于真实物理，主要元素是漫反射，反射（RGB贴图），光泽度（RGB贴图），法线贴图。优点是边缘伪像不明显，控制灵活，缺点是灵活控制可能不遵守能量守恒破坏PBR原则，并且RGB贴图多，占用内存多。

高度贴图：类似法线贴图，有着增强细节的效果，把高度值保存起来。

Unity支持两种工作流，Cocos，Laya，UE4只支持主流的金属与粗糙度

美术提供：物体本身贴图，金属度贴图，粗糙度贴图。

在Unity中，名为Standard的shader就是基于PBR的。
其中参数如下：
Albedo：本色贴图
Metallic：金属度，可以调一个值，也可以传贴图
Smoothess：光泽度，可以调值，里面的Source选项中，可以选择粗糙度的来源（本色贴图还是金属度），因为一般金属度和粗糙度用两个通道（R和A）做到一个贴图中。
Normal Map：法线贴图
Height Map：高度贴图
Occlusion：环境遮挡
Detail Mask：细Detail Mask是一种用于控制细节纹理的遮罩或掩模。细节纹理通常用于增加表面的细微细节，例如皮肤上的皱纹、石头上的裂纹等，从而增加物体的真实感。通过定义一个遮罩图像来指定哪些区域应用细节纹理。这个遮罩图像是一个灰度图，其中不同的灰度值表示不同的遮罩强度。通常，灰度值较高的区域将更多地受到细节纹理的影响，而灰度值较低的区域则保留原始的基础材质。
Emission：自发光，可以选择颜色或贴图

渲染队列与ZTest，ZWrite

普通情况下，绘制画面时，绘制最远处的物体，然后绘制近处物体，这样就能覆盖掉远处物体。但是绘制的时候做了优化，先绘制近的，再绘制远的，如果远的被挡住了，就不进行绘制，远近不是相对于一整个物体来说的，而是相对于一个个片元。
先绘制的物体会把片元放入颜色缓存区和深度缓冲区，绘制后面的片元的时候，比较深度，如果深度比原来的小，那么就把这个新的片元放入原来的颜色缓冲区和深度缓冲区。如果不是，这个片元信息会被丢弃，称为没有通过深度测试（ZTest）。把片元信息更新到深度缓存区称为ZWrite。如果关掉深度缓存，虽然颜色会更新，但是深度不会更新。
深度测试有不同规则：
ALWAY：颜色都会通过测试
NEVER：颜色永远无法通过测试
LESS：距离摄像机越近的通过测试
EQUAL：距离相等的通过测试
GREATER：距离摄像机越远的通过测试
NOT_EQUAL：距离不相等的通过测试

如果一个物体的shader把深度测试设定为ALWAY，那么永远都能绘制到屏幕中。

绘制透明物体（第四维的透明度数值alpha不是1）的时候，可以采用不同的渲染队列，每个队列有不同的编号，场景的物体会根据队列存放。游戏引擎先绘制编号小的队列，再绘制编号大的队列，不同的队列都有不同的颜色和深度缓冲区。
不同队列直接的颜色不会被遮挡，但是会混合，所以通过不同渲染队列透明物体看其他物体时是两种物体的混合色。这个过程叫Blend。
Blend有几种混合模式：

直接覆盖（默认）
透明度混合（常用）

// 根据后面绘制物体的透明度混合，例如后面队列的透明物体Alpha为30%，则按照30%透明物体颜色和70%缓存的物体颜色绘制，src是本色，dst是颜色缓存
Blend SrcAlpha OneMinusSrcAlpha
// 线性叠加
Blend One One
// 正片叠底，相乘Multiply
Blend DstColor Zero

通过在透明物体shader上设置上面代码可以达到对应效果

立方体纹理采样和自制天空盒

天空盒其实就是一个立方体或球体，立方体有六个面，每个面都可以对应一个纹理贴图。如果这六个贴图在边缘处是连续的，那么就可以看成一个整体。
对于天空盒来说，其渲染颜色只由本色决定，创建天空盒（立方体或球体），包围住整个场景，并编写Shader控制渲染盒子，然后调整渲染队列顺序（调到最小），使其最先绘制。
我们需要创建一个Cubemap的纹理，它可以设置立方体的六张贴图。

Shader "Bycw/BycwSkyBox"
{
    Properties
    {
        // 这是Cube纹理，不是一般的纹理
        _MainTex ("Texture", Cube) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Cull Off     // 背对摄像机的面不会被裁掉;
        ZWrite Off   // 关掉深度缓存
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"

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

            };

            struct v2f
            {
                // 立方体原点指向顶点的向量
                float3 dir : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };
            // 纹理贴图
            samplerCUBE _MainTex; 

            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                // 通过模型顶点得到向量
                o.dir = v.vertex;
                
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // i.uv变成i.dir了
                fixed4 col = texCUBE(_MainTex, i.dir);
                // fixed4 col = fixed4(1.0, 0, 0, 1.0);
                return col;
            }
            ENDCG
        }
    }
}

向前渲染管线

向前渲染：一种Unity内置的渲染管线，其包含多光源的光照计算，分为两个部分：base和additional：

base：包含最重要的逐像素光源+逐顶点光源+SH光源+LightMap+环境光，称为一个Pass
Additional：其他重要的逐像素光源，一个光源一个Pass

如何处理多光源光照计算：
每个光源可以设置渲染模式为：Auto，Important，Not Important
Important是逐像素光照，Not Important是逐顶点光照和SH光源的计算。Important光源的数量决定Pass的数量。因此每个重要光源都会做一次光照计算。
float4 _LightColor0:该Pass处理的重要光源的颜色
float4 _WorldSpaceLightPos0：重要光源的位置，如果是平行光，_WorldSpaceLightPos0.w为0，其余为1
float4x4 LightMatrix0:从世界空间到光源空间的变换矩阵，可以用于采样cookie和光强衰减(attenuation)纹理
unity_4LightPosX0:
unity_4LightPosY0:
unity_4LightPosZ0:仅用于BasePass，前四个非重要点光源在世界空间中的位置
float4 unity_4LightAtten0:仅用于BasePass，储存4个非重要点光源的刷减因子

float4 unity_4LightColor:仅用于BasePass，储存4个非重要点光源的颜色

Shader "Bycw/BycwForward"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        
        LOD 100

        Pass
        {
            // 向前渲染
            Tags { "RenderType"="Opaque" "LightMode"="ForwardBase" }

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            //预编译指令，用于前向渲染计算basePass
            #pragma multi_compile_fwdbase

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

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

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;

            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // sample the texture
                fixed4 col = tex2D(_MainTex, i.uv);
                //unity_LightColor存储四个非重要光源颜色，_LightColor0是本Pass唯一重要的光源
                float4 lightColor = _LightColor0 + unity_LightColor[0] + unity_LightColor[1] + unity_LightColor[2] + unity_LightColor[3];
                // 本身乘光照
                col = col * lightColor;
                return col;
            }
            ENDCG
        }

         Pass
        {
            // 一个其他重要的光源
            Tags { "RenderType"="Opaque" "LightMode"="ForwardAdd" }
            // 混合光照
            Blend One One

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // 预编译，其他重要的光源
            #pragma multi_compile_fwdadd

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

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

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;

            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // sample the texture
                fixed4 col = tex2D(_MainTex, i.uv);
                // fixed4 col = fixed4(1, 1, 1, 1);
                col = col * _LightColor0;
                return col;
            }
            ENDCG
        }
    }

    
}

渲染管线设置

每个摄像机都会绘制一个场景，因此渲染管线的设置在摄像机上：

Rendering Path：
    Use Graphics Setting：默认是向前渲染，在Player Setting->Graphics->Randing Path中设置
    Forward：向前渲染
    Delay：演示渲染

重要光源数目可以在Project Setting->Quality->Pixel Light Count设置

光照衰减计算

计算方式：
点光源：球体衰减，中心是1，超过最远距离是0
聚光灯：垂直衰减和水平衰减
衰减系数可以通过计算，也可以事先存到纹理中读取（主流）

Shader "Bycw/BycwLightAtten"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        
        LOD 100

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

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

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

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

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // sample the texture
                fixed4 col = tex2D(_MainTex, i.uv);
                // 平行光的衰减因子
                float atten = 1.0;

                col = col * _LightColor0 * atten;
                return col;
            }
            ENDCG
        }

        Pass
        {
            Tags { "RenderType"="Opaque" "LightMode"="ForwardAdd" }
            Blend One One

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fwdadd

            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            // 需要这个头文件
            #include "AutoLight.cginc"

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

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

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                return o;
            }

            // 重要光源;
            fixed4 frag (v2f i) : SV_Target
            {   
                
                /*     
                float atten = 1.0;
                #ifdef USING_DIRECTIONAL_LGITH
                    fixed atten = 1.0;
                #else
                    //点光源
                    #if defined(POINT)
                        // 把片元的世界坐标转移到以点光源为参考的坐标
                        float3 lightCoord = mul(unity_WorldToLight,float4(i.worldPos,1)).xyz;
                        //使用点到光源的距离值的平方来取样，可以避开开方操作
                        //使用宏UNITY_ATTEN_CHANNEL来得到衰减纹理中衰减值所在的分量，以得到最终的衰减值。
                        fixed atten = tex2D(_LightTexture0,dot(lightCoord,lightCoord).rr).UNITY_ATTEN_CHANNEL;
                    //聚光灯
                    #elif defined(SPOT)
                        float4 lightCoord = mul(unity_WorldToLight,float4(i.worldPos,1));
                        //角度衰减 * 距离衰减
                        // _LightTexture0是衰减系数纹理
                        fixed atten = (lightCoord.z > 0) * tex2D(_LightTexture0,lightCoord.xy/lightCoord.w + 0.5).w * tex2D(_LightTextureB0,dot(lightCoord,lightCoord).rr).UNITY_ATTEN_CHANNEL;
                    #else
                        fixed atten = 1.0;
                    #endif
                #endif
                */
                // 采用Unity内置的宏计算，原理和上面代码一致
                UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
                
                // 自己算
                // float r = distance(i.worldPos, _WorldSpaceLightPos0);
                // float atten = 1- (r / 10);
                // end

                fixed4 col = tex2D(_MainTex, i.uv);
                col = col * _LightColor0 * atten;
                return col;
            }
            ENDCG
        }
    }
}

阴影计算原理

步骤：

计算阴影区域
在阴影区域叠加颜色

计算区域的时候，光源相当于摄像机，光源看不见的地方没有阴影。Shader中会编写一个特殊的Pass，计算阴影时调用。我们需要把片元坐标转换为以光源为中心的坐标，并通过光源计算每个片元的深度信息，如果某个地方的深度比光源照到的地方大，那么就是阴影。这个深度信息会提供给引擎，通过其他shader接收阴影。

在物体属性Mesh Renderer中，可以在Lighting中调节Cast Shadows，如果关闭，物体阴影投射的pass不会被调用，也就没有阴影。Receive Shadows可以设置是否接收阴影。
物体投射阴影的时候，会产生Pass，因此DrawCall会加1

Shader "Bycw/BycwShadow"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100
        
        // 投影Pass, 摄像机在我们光源的位置;
        Pass {
            // 标注模式为阴影投射
            Tags {"LightMode"="ShadowCaster"}
            

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // 预编译
            #pragma multi_compile_shadowcaster

            #include "UnityCG.cginc"

            struct v2f {                
                V2F_SHADOW_CASTER; //宏相当于 float3 vec : TEXCOORD0; float4 pos : SV_POSITION
            };

            v2f vert(appdata_base v) {
                v2f o;
                TRANSFER_SHADOW_CASTER_NORMALOFFSET(o);
                // 相当于
                // o.vec = mul(unity_ObjectToWorld, v.vertex).xyz - _LightPositionRange.xyz;
                //opos = UnityObjectToClipPos(v.vertex)
                return o;
            }

            float4 frag(v2f i): SV_Target {
                SHADOW_CASTER_FRAGMENT(i)
                // 相当于
                // return UnityEncodeCubeShadowDepth((length(i.vec) + unity_LightShadowBias.x) * _LightPositionRange.w)
                // 把深度信息传出去了
            }
            ENDCG    
        }
            
        // Base Pass
        Pass
        {
            Tags {"LightMode"="ForwardBase"}

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

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

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

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 pos : SV_POSITION;
                // 根据阴影坐标，你可以获取深度信息,获取阴影的颜色值;
                SHADOW_COORDS(1) // unityShadowCoord4 _ShadowCoord : TEXCOORD1;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                // 算出阴影坐标
                TRANSFER_SHADOW(o); // o._ShadowCoord = ComputeScreenPos(o.pos);
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = tex2D(_MainTex, i.uv);
                // 根据我们的阴影的坐标，把阴影的数据获取出来,得到阴影颜色
                fixed shadow = SHADOW_ATTENUATION(i); // unitySampleShadow(i._ShadowCoord)
                // 光的颜色乘以阴影（0到1的值，表示光线在阴影区域的衰减程度或透明度）
                float4 lightColor = _LightColor0 * shadow;
                return col * lightColor;
            }
            ENDCG
        }
        

    }
    
}

GPU并发计算（compute shadder）

GPU的线程和CPU不同，线程由硬件实现，每个线程都有自己的执行上下文和寄存器，可以单独执行计算任务，而这种计算单元有成千上万个，可以实现高效的并行计算。CPU缓存大、逻辑运算ALU较少；GPU逻辑运算较多，缓存较小。相较之下，GPU有更多的运算单元，即干活的人多了。GPU 包含数千个并行计算单元，称为 CUDA 核心。这些 CUDA 核心可以同时处理多个数据流，从而实现高效的并行计算。CUDA 核心还包含了一些特殊的硬件单元，例如浮点数处理单元、整数处理单元、逻辑单元和共享内存等，可以提供快速的数学运算和数据处理能力。
GPU中，线程被组织成线程组，每个线程组包含多个线程，维度可以用numthreads(x,y,z)设置，GPU会根据线程组的大小和维度自动分配线程资源，并将计算任务分配给每个线程

案例：控制GPU计算1024个sqrt计算

GPU代码：Unity中创建Compute Shader,GPU的代码指令中有Kernel的概念，并行计算的函数入口都可以放到kernel里面。
例如下面的函数CSSqrtMain会排到kernel0，每个这样的函数都有一个KernalIndex

// Each #kernel tells which function to compile; you can have many kernels
#pragma kernel CSSqrtMain

RWStructuredBuffer<float> inputData; // 用于接受CPU传递过来的数据
RWStructuredBuffer<float> outputData; // 用于返回给GPU的数据;

// 分配线程组
[numthreads(64,1,1)]
void CSSqrtMain(uint3 id : SV_DispatchThreadID)// id是三维的
{
    outputData[id.x] = sqrt(inputData[id.x]);
}

常见的读写缓存区数据类型如下：
RWBuffer：这个类型是用于读写一维数据的缓冲区类型，可以用于存储任意类型的数据，例如float、int等。可以使用SetData和GetData函数将数据写入和读出缓冲区。
RWByteAddressBuffer：这个类型也是用于读写一维数据的缓冲区类型，但它是按字节寻址的，可以用于存储任意类型的数据。可以使用SetData和GetData函数将数据写入和读出缓冲区。
RWStructuredBuffer：这个类型是用于读写结构化数据的缓冲区类型，可以用于存储自定义的结构体类型。可以使用SetData和GetData函数将数据写入和读出缓冲区。
RWTexture1D：这个类型是用于读写一维纹理数据的缓冲区类型，可以用于存储颜色或其他类型的数据。可以使用SetPixel和GetPixel函数将数据写入和读出缓冲区。
RWTexture1DArray：这个类型是用于读写一维纹理数组数据的缓冲区类型，可以用于存储颜色或其他类型的数据。可以使用SetPixel和GetPixel函数将数据写入和读出缓冲区。
RWTexture2D：这个类型是用于读写二维纹理数据的缓冲区类型，可以用于存储颜色或其他类型的数据。可以使用SetPixel和GetPixel函数将数据写入和读出缓冲区。
RWTexture2DArray：这个类型是用于读写二维纹理数组数据的缓冲区类型，可以用于存储颜色或其他类型的数据。可以使用SetPixel和GetPixel函数将数据写入和读出缓冲区。
RWTexture3D：这个类型是用于读写三维纹理数据的缓冲区类型，可以用于存储颜色或其他类型的数据。可以使用SetPixel和GetPixel函数将数据写入和读出缓冲区。

CPU传递数据需要使用ComputeBuffer：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class MySqrtGPU : MonoBehaviour
{
    private static int itemCount = 1024;
    // 编辑器绑定GPU脚本
    public ComputeShader mysqrtGPUShader = null;

    ComputeBuffer inputData = null;
    ComputeBuffer outputData = null;

    void Start()
    {
        inputData = new ComputeBuffer(itemCount, sizeof(float));
        outputData = new ComputeBuffer(itemCount, sizeof(float));

        float[] rawInputData = new float[itemCount];
        for (int i = 0; i < itemCount; i++) {
            rawInputData[i] = (float)(i);
        }
        // 设置传递数据
        inputData.SetData(rawInputData);
        // 查找对应的KernalIndex
        int kernelIndex = this.mysqrtGPUShader.FindKernel("CSSqrtMain");
        // 关联数据
        this.mysqrtGPUShader.SetBuffer(kernelIndex, "inputData", inputData);
        this.mysqrtGPUShader.SetBuffer(kernelIndex, "outputData", outputData);
        // 执行对应kernelIndex的函数
        this.mysqrtGPUShader.Dispatch(kernelIndex, itemCount / 64, 1, 1);
        // 取出结果
        float[] result = new float[itemCount];
        outputData.GetData(result);

        for (int i = 0; i < itemCount; i++) {
            Debug.Log("sqrt(" + i + ") = " + result[i]);
        }
    }
}