Unity Shader开发入门 (DLC)

Shader "Unlit/SequentialFrameAnimation"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //图集行列
        _Rows("Rows", int) = 8
        _Columns("Columns", int) = 8
        //切换动画速度变量
        _Speed("Speed", float) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float _Rows;
            float _Columns;
            float _Speed;

            v2f vert (appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.texcoord;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                //得到当前帧 利用时间变量计算
                float frameIndex = floor(_Time.y * _Speed) % (_Rows * _Columns);
                //小格子（小图片）采样时的起始位置计算
                //除以对应的行和列 目的是将行列值 转换到 0~1的坐标范围内
                //1 - (floor(frameIndex / _Columns) + 1)/_Rows
                //  +1 是因为把格子左上角转换为格子左下角(想拿到这行的底边的 UV 坐标，而不是顶边)
                //  1- 因为UV坐标采样时从左下角进行采样的
                float2 frameUV = float2(frameIndex % _Columns / _Columns, 1 - (floor(frameIndex / _Columns) + 1)/_Rows);
                //得到uv缩放比例 相当于从0~1大图 隐射到一个 0~1/n的一个小图中
                float2 size = float2(1/_Columns, 1/_Rows);
                //计算最终的uv采样坐标信息
                //*size 相当于把0~1范围 缩放到了 0~1/8范围
                //+frameUV 相当于把起始的采样位置 移动到了 对应帧小格子的起始位置
                float2 uv = i.uv * size + frameUV;
                //最终采样颜色
                return tex2D(_MainTex, uv);
            }
            ENDCG
        }
    }
}

Shader "Unlit/ScrollingBackground"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        //水平和竖直的滚动速度
        _ScrollSpeedU("ScrollSpeedU", float) = 0.5
        _ScrollSpeedV("ScrollSpeedV", float) = 0.5
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
          

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float _ScrollSpeedU;
            float _ScrollSpeedV;

            v2f vert (appdata_base v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.texcoord;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                //利用时间 来计算UV的偏移 因为时间一直在变化 所以最终的uv坐标也不停地在变 
                float2 scrollUV = frac(i.uv + float2(_Time.y * _ScrollSpeedU, _Time.y * _ScrollSpeedV));
                return tex2D(_MainTex, scrollUV);
            }
            ENDCG
        }
    }
}

Shader "Unlit/2DWater"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color("Color", Color) = (1,1,1,1)
        //波动幅度
        _WaveAmplitude("WaveAmplitude", Float) = 1
        //波动频率
        _WaveFrequency("WaveFrequency", Float) = 1
        //波长的倒数
        _InvWaveLength("InvWaveLength", Float) = 1

        //纹理变化速度
        _Speed("Speed", Float) = 1
    }
    SubShader
    {
        //透明Shader相关渲染标签 + 关闭批处理标签
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" "DisableBatching"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float4 _Color;
            float _WaveAmplitude;
            float _WaveFrequency;
            float _InvWaveLength;
            float _Speed;

            v2f vert (appdata_base v)
            {
                v2f o;
                //模型空间下的偏移位置
                float4 offset;
                //让它在模型空间的x轴方向进行偏移(请注意，这里的方向得看模型空间自身方向的)
                offset.x = sin(_Time.y * _WaveFrequency + v.vertex.z * _InvWaveLength) * _WaveAmplitude;
                offset.yzw = float3(0,0,0);
                o.vertex = UnityObjectToClipPos(v.vertex + offset);

                o.uv = v.texcoord * _MainTex_ST.xy + _MainTex_ST.zw;

                o.uv += float2(0, _Time.y *_Speed );

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 color = tex2D(_MainTex,i.uv);
                color.rgb *= _Color.rgb;
                return color;
            }
            ENDCG
        }
    }
}

Shader "Unlit/Lesson95_Billboarding"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color("Color", Color) = (1,1,1,1)
        //用于控制垂直广告牌和全向广告牌的变化
        _VerticalBillboarding("VerticalBillboarding", Range(0,1)) = 1
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" "DisableBatching"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha
            Cull Off

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            fixed4 _Color;
            float _VerticalBillboarding;

            v2f vert (appdata_base v)
            {
                v2f o;
                //新坐标系的中心点（默认我们还是使用的模型空间原定，这里的center可以实现在非轴心点进行程序化旋转，下文会提到）
                float3 center = float3(0,0,0);
                //计算Z轴（normal）
                float3 cameraInObjectPos = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1));
                //得到Z轴对应的向量
                float3 normalDir = cameraInObjectPos - center;
                //相当于把y往下压，如果_VerticalBillboarding是0 就代表把我们Z轴压到了xz平面 如果是1 那么就是正常的视角方向
                normalDir.y *= _VerticalBillboarding;
                //单位化Z轴
                normalDir = normalize(normalDir);
                //模型空间下的Y轴正方向 作为它的 old up
                //为了避免z轴和010重合 ，因为重合后再计算叉乘 可能会得到0向量
                float3 upDir = normalDir.y > 0.999 ? float3(0,0,1) : float3(0,1,0);
                //利用叉乘计算X轴（right）
                float3 rightDir = normalize(cross(upDir, normalDir));
                //去计算我们的Y轴 也就是newup
                upDir = normalize(cross(normalDir, rightDir));

                //得到顶点相对于新坐标系中心点的偏移位置
                float3 centerOffset = v.vertex.xyz - center;
                //利用3个轴向进行最终的顶点位置的计算
                float3 newVertexPos = center + rightDir * centerOffset.x + upDir * centerOffset.y + normalDir * centerOffset.z;
                //把新顶点转换到裁剪空间
                o.vertex = UnityObjectToClipPos(float4(newVertexPos, 1));

                //uv坐标偏移缩放
                o.uv = v.texcoord.xy * _MainTex_ST.xy + _MainTex_ST.zw;

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float4 color = tex2D(_MainTex, i.uv);
                color.rgb *= _Color.rgb;
                return color;
            }
            ENDCG
        }
    }
}

MeshFilter meshFilter = GetComponent<MeshFilter>();
if (meshFilter != null)
{
    Mesh mesh = meshFilter.mesh;
    Vector3[] vertices = mesh.vertices;
    Color[] colors = new Color[vertices.Length];

    for (int i = 0; i < vertices.Length; i++)
    {
        // 将模型空间位置存储在顶点颜色中
        colors[i] = new Color(vertices[i].x, vertices[i].y, vertices[i].z, 1);
    }

    mesh.colors = colors;
}

Shader "Unlit/Lesson97"
{
     Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color("Color", Color) = (1,1,1,1)
        //波动幅度
        _WaveAmplitude("WaveAmplitude", Float) = 1
        //波动频率
        _WaveFrequency("WaveFrequency", Float) = 1
        //波长的倒数
        _InvWaveLength("InvWaveLength", Float) = 1

        //纹理变化速度
        _Speed("Speed", Float) = 1
    }
    SubShader
    {
        //透明Shader相关渲染标签 + 关闭批处理标签
        Tags { "RenderType"="Transparent" "Queue"="Transparent" "IgnoreProjector"="True" "DisableBatching"="True" }

        Pass
        {
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha

            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

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

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float4 _Color;
            float _WaveAmplitude;
            float _WaveFrequency;
            float _InvWaveLength;
            float _Speed;

            v2f vert (appdata_base v)
            {
                v2f o;
                //模型空间下的偏移位置
                float4 offset;
                //让它在模型空间的x轴方向进行偏移
                offset.x = sin(_Time.y * _WaveFrequency + v.vertex.z * _InvWaveLength) * _WaveAmplitude;
                offset.yzw = float3(0,0,0);
                o.vertex = UnityObjectToClipPos(v.vertex + offset);

                o.uv = v.texcoord * _MainTex_ST.xy + _MainTex_ST.zw;

                o.uv += float2(0, _Time.y *_Speed );

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 color = tex2D(_MainTex,i.uv);
                color.rgb *= _Color.rgb;
                return color;
            }
            ENDCG
        }

        //该注释主要用于进行阴影投影 主要是用来计算阴影映射纹理的
        Pass{
            Tags{"LightMode" = "ShadowCaster"}
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            //  该编译指令时告诉Unity编译器生成多个着色器变体
            //  用于支持不同类型的阴影（SM，SSSM等等）
            //  可以确保着色器能够在所有可能的阴影投射模式下正确渲染
            #pragma multi_compile_shadowcaster
            //  其中包含了关键的阴影计算相关的宏
            #include "UnityCG.cginc"

            struct v2f{
                //顶点到片元着色器阴影投射结构体数据宏
                //这个宏定义了一些标准的成员变量
                //这些变量用于在阴影投射路径中传递顶点数据到片元着色器
                //我们主要在结构体中使用
                V2F_SHADOW_CASTER;
            };

            float _WaveAmplitude;
            float _WaveFrequency;
            float _InvWaveLength;

            v2f vert(appdata_base v)
            {
                v2f data;
                //模型空间下的偏移位置
                float4 offset;
                //让它在模型空间的x轴方向进行偏移
                offset.x = sin(_Time.y * _WaveFrequency + v.vertex.z * _InvWaveLength) * _WaveAmplitude;
                offset.yzw = float3(0,0,0);
                //需要进行顶点偏移位置的修改
                //直接在模型空间下顶点坐标进行计算即可
                v.vertex = v.vertex + offset;
                //o.vertex = UnityObjectToClipPos(v.vertex + offset);

                //转移阴影投射器法线偏移宏
                //用于在顶点着色器中计算和传递阴影投射所需的变量
                //主要做了
                //2-2-1.将对象空间的顶点位置转换为裁剪空间的位置
                //2-2-2.考虑法线偏移，以减轻阴影失真问题，尤其是在处理自阴影时
                //2-2-3.传递顶点的投影空间位置，用于后续的阴影计算
                //我们主要在顶点着色器中使用
                TRANSFER_SHADOW_CASTER_NORMALOFFSET(data);
                return data;
            }

            float4 frag(v2f i):SV_Target
            {
                //阴影投射片元宏
                //将深度值写入到阴影映射纹理中
                //我们主要在片元着色器中使用
                SHADOW_CASTER_FRAGMENT(i);
            }

            ENDCG
        }
    }
    Fallback "VertexLit"
}

Mesh Renderer(网格渲染器)

  └── Mesh(网格) ―― MeshFilter(网格过滤器组件进行关联)

        └── Geometry Data(几何数据)

  └── Material(材质)

        └── Shader(着色器)

        └── Properties(属性：颜色、纹理等 ―― 在Shader中决定哪些属性暴露在材质上)

Skinned Mesh Renderer(蒙皮网格渲染器)

  └── Mesh(网格)

        └── Geometry Data(几何数据)

  └── Bones & Weights(骨骼与权重)

  └── Material(材质)

        └── Shader(着色器)

        └── Properties(属性：颜色、纹理等 ―― 在Shader中决定哪些属性暴露在材质上)

private Material material;
public Color color;
[Range(0,1)]
public float fresnelScale;

private void Start() {
    //获取对象的渲染器
    Renderer renderer = GetComponent<Renderer>();
    if(renderer != null)
    {
        //sharedMaterial和material的区别
        //sharedMaterial:一个是改一个都变
        //material:一个是改一个不会影响其它使用相同材质球的对象
        //得到主材质球
        material = renderer.material;//renderer.sharedMaterial;
        //得到所有的材质球
        Material[] materials = renderer.sharedMaterials; //renderer.materials;
        //修改颜色
        material.color = color;
        //修改主纹理
        material.mainTexture = Resources.Load<Texture2D>("路径");

        if(material.HasColor("_Color"))
        {
            material.SetColor("_Color", color);
            print(material.GetColor("_Color"));
        }
            

        if(material.HasFloat("_FresnelScale"))
            material.SetFloat("_FresnelScale", fresnelScale);

        //修改渲染队列
        material.renderQueue = 2000;

        //修改材质球使用的shader
        material.shader = Shader.Find("Unlit/Lesson80_Fresnel");

        material.SetTextureOffset("_MainTex", new Vector2(0.5f, 0.5f));
        material.SetTextureScale("_MainTex", new Vector2(0.5f, 0.5f));
}

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

[ExecuteInEditMode]
[RequireComponent(typeof(Camera))]
public class PostEffectBase : MonoBehaviour
{
    //屏幕后处理效果会使用的Shader
    public Shader shader;
    //一个用于动态创建出来的材质球 就不用再工程中手动创建了
    private Material _material;

    protected virtual void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        //判断这个材质球是否为空 如果不为空 就证明这个shader能用来处理屏幕后处理效果
        if (material != null)
            Graphics.Blit(source, destination, material);
        else//如果为空 就不用处理后处理效果了 直接显示原画面就可以了
            Graphics.Blit(source, destination);
    }

    protected Material material
    {
        get
        {
            //如果shader 没有 或者有但是不支持当前平台
            if (shader == null || !shader.isSupported)
                return null;
            else
            {
                //避免每次调用属性都去new材质球
                //如果之前new过了，并且shader也没有变化
                //那就不用new了 直接返回使用即可
                if (_material != null && _material.shader == shader)
                    return _material;
                //除非材质球是空的 或者shader变化了 才会走下面的逻辑

                //用支持的shader动态创建一个材质球 用于渲染
                _material = new Material(shader);
                //不希望材质球被保存下来 因此我们家一个标识
                _material.hideFlags = HideFlags.DontSave;
                return _material;
            }
        }
    }
}