yzyCli/u3d/Assets/LuaFramework/AssetBundleRes/scene/object/shader/MainRoleProEffectCG.cginc

#ifndef MAINROLE_EFFECT_CG_INCLUDED
#define MAINROLE_EFFECT_CG_INCLUDED

#include "UnityCG.cginc"

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

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

struct v2f
{
    float4 pos : SV_POSITION;
    float2 uv : TEXCOORD0;
    float4 posWorld : TEXCOORD1;
    float3 normalDir : TEXCOORD2;
    float3 dir_rimlight : TEXCOORD3;
    float3 dir_shadow : TEXCOORD4;
};

struct v2f_hg
{
    float4 pos : SV_POSITION;
    float2 uv : TEXCOORD0;
    float4 posWorld : TEXCOORD1;
    float3 normalDir : TEXCOORD2;
    float4 mPos : TEXCOORD3;
};

fixed4 _Color;
float4 _ShadowDir, _RimDir;

// 通用顶点函数，主要内容为转化顶点坐标和发现坐标，以及归一化边缘方向和法线方向
v2f MainRoleVertexDefault(a2v v)
{
    v2f o;
    o.posWorld = mul(unity_ObjectToWorld, v.vertex);
    o.pos = mul(UNITY_MATRIX_VP, o.posWorld);
    o.uv = v.uv;

    o.normalDir = mul((float3x3)unity_ObjectToWorld, v.normal);

    o.dir_rimlight = normalize(_RimDir.xyz);
    o.dir_shadow = normalize(_ShadowDir.xyz);

    return o;
}

float4 _HologramGliterData1, _HologramGliterData2;
float3 VertexHologramOffset(float3 vertex, half4 offsetData)
{
    float speed = offsetData.x;
    float range = offsetData.y;
    float offset = offsetData.z;
    float frequency = offsetData.w;

    float offset_time = sin(_Time.y * speed);
    // step(y, x) 如果 x >= y 则返回1，否则返回0
    float timeToGliter = step(frequency, offset_time);
    float gliterPosY = sin(vertex.x + _Time.z);
    float gliterPosYRange = step(0, gliterPosY) * step(gliterPosY, range);
    // 获取偏移量
    float res = gliterPosYRange * offset * timeToGliter * gliterPosY;

    // 将这个偏移量定义为视角坐标的偏移量，再转到模型坐标
    float3 view_offset = float3(res, 0, 0);
    return mul((float3x3)UNITY_MATRIX_T_MV, view_offset);
}

v2f_hg MainRoleHologramMaskVertex(a2v_hg v)
{
    v2f_hg o;
    // 产生模型顶点方向上的扭曲系数
    v.vertex.xyz += VertexHologramOffset(v.vertex.xyz, _HologramGliterData1);
    v.vertex.xyz += VertexHologramOffset(v.vertex.xyz, _HologramGliterData2);

    o.posWorld = mul(unity_ObjectToWorld, v.vertex);
    o.pos = mul(UNITY_MATRIX_VP, o.posWorld);
    o.uv = v.uv;
    o.normalDir = mul((float3x3)unity_ObjectToWorld, v.normal);

    return o;
}

// 全息专用顶点函数，相比于通用顶点函数多了顶点偏移的逻辑
v2f_hg MainRoleHologramVertex(a2v_hg v)
{
    v2f_hg o;
    // 产生模型顶点方向上的扭曲系数
    v.vertex.xyz += VertexHologramOffset(v.vertex.xyz, _HologramGliterData1);
    v.vertex.xyz += VertexHologramOffset(v.vertex.xyz, _HologramGliterData2);
    o.mPos = v.vertex;
    o.posWorld = mul(unity_ObjectToWorld, v.vertex);
    o.pos = mul(UNITY_MATRIX_VP, o.posWorld);
    o.uv = v.uv;
    o.normalDir = mul((float3x3)unity_ObjectToWorld, v.normal);

    return o;
}

// MainRole参数
sampler2D _MainTex, _Mask, _MatcapTex;
float4 _AmbientColor, _SunColor, _BrightShadow, _DarkShadow, _RimColor;
float _Shadownol1, _Shadownol2, _MatcapScale1, _MatcapScale2;
// 溶解效果参数
sampler2D _DissolveMap;  
float4 _DissolveMap_ST;
fixed4 _DissolveFadeInColor, _DissolveFadeMidColor, _DissolveFadeOutColor;  
fixed _DissolveThreshold, _DissolveFadeInThreshold, _DissolveFadeMidThreshold, _DissolveFadeOutThreshold;  
// 全息效果
sampler2D _HologramGlitchMap;
fixed4 _HologramColor;
half _HologramAlpha;
half _HologramColorGlitchTog, _HologramColorGlitch, _HologramColorGlitchMin;
half4 _HologramColorGlitchData;
// 全息菲涅尔
half _FresnelScale, _FresnelPower, _FresnelAlphaScale, _FresnelAlphaPower;
// 全息扫描线
sampler2D _HologramLine1;
half _HologramLine1Speed, _HologramLine1Frequency, _HologramLine1Alpha;
sampler2D _HologramLine2;
half _HologramLine2Speed, _HologramLine2Frequency, _HologramLine2Alpha;
// 全息颜色颗粒
half4 _HologramGrainData;
half _HologramGrainSpeed, _HologramGrainAffect;
// 全息蒙版
sampler2D _HologramMaskMap;
half _HologramMaskAffect, _HologramMaskUseAxis, _HologramYMask;
float4 _HologramMaskMap_ST;
// 全息+溶解参数
fixed4 _AlphaTexColor;
float _ModelHeightButton, _ModelHeightTop, _DissolveFadeGap;
fixed _ReverseDissolveDirection;

float4 MainRoleOpaqueFragment(v2f i) : SV_Target
{
    float3 mainColor = tex2D(_MainTex, i.uv).rgb;
    #if defined(_USE_DISSOLVE_EFFECT)
        // 不满足阈值的片元直接舍弃
        #if defined (_USE_DISSOLVE_MAP)
            float2 dissolve_uv = TRANSFORM_TEX(i.uv, _DissolveMap);
            fixed4 dissolveValue = tex2D(_DissolveMap, dissolve_uv); 
            if (dissolveValue.r < _DissolveThreshold)  
        #else
            if (mainColor.r < _DissolveThreshold)  
        #endif
        {  
            discard;  
        }  
    #endif

    float3 diffuse_fac = _SunColor + _AmbientColor.xyz;
    float3 diffuse = mainColor * 0.5 * 1.2784 * diffuse_fac;

    float3 N = normalize(i.normalDir);
    float3 L = i.dir_shadow.xyz;

    float4 resultColor;
    float3 V = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
    float NdotView = clamp(dot(N, V), 0.0, 1.0);
    float NdotshadowFactor = clamp(dot(L, N), 0.0, 1.0);
    float RimlightDotValue = clamp(dot(i.dir_rimlight, N), 0.0, 1.0);
    float Ndotshadow = smoothstep(_Shadownol1, _Shadownol2, NdotshadowFactor);

    float dif_illum = dot(diffuse, float3(0.299, 0.587, 0.114));
    float shadowshift = smoothstep(0.25, 0.74, dif_illum);
    float3 shadowColor = lerp(_DarkShadow.rgb, _BrightShadow.rgb, shadowshift);
    float3 baseColor = lerp(shadowColor * diffuse.rgb, diffuse.rgb, Ndotshadow);

    float rimdot = clamp(RimlightDotValue * (1.0 - NdotView), 0.0, 1.0);
    float rimffcal = smoothstep(0.35, 0.58, rimdot);
    float3 rim = rimffcal * diffuse * _RimColor.rgb;

    resultColor.rgb = baseColor + rim;
    float3 maskTemp = tex2D(_Mask, i.uv).rgb;
    float2 matcapuv = mul((float3x3)UNITY_MATRIX_V, N).xy;
    matcapuv.y = -matcapuv.y;
    matcapuv = matcapuv * 0.5 + 0.5;
    float3 matColor1 = tex2D(_MatcapTex, float2(matcapuv.x * 0.5, matcapuv.y)).rgb;
    float3 matColor2 = tex2D(_MatcapTex, float2(matcapuv.x * 0.5 + 0.5, matcapuv.y)).rgb;

    float matColor = (matColor1 * maskTemp.x * _MatcapScale1 + matColor2 * maskTemp.y * _MatcapScale2);

    resultColor.rgb += (matColor * diffuse + maskTemp.z * diffuse);
    resultColor.a = 1;
    resultColor *= _Color;

    #if defined(_USE_DISSOLVE_EFFECT)
        // 溶解相关
        // percentage 讲道理不会大于1的，大于1的情况上面就被迪斯咯的了，但pectange的整体趋势是随着_DissolveThreshold增加而增加这个是肯定的
        #if defined (_USE_DISSOLVE_MAP)
            fixed percentage = _DissolveThreshold / max(dissolveValue.r, 0.0001);  
        #else
            fixed percentage = _DissolveThreshold / max(mainColor.r, 0.0001);  
        #endif
        // 设置 溶解颜色->完全消融 的颜色过度
        // sign 根据范围返回一个标志，分别是小于0时返回-1，大于0时返回1，否则返回0（不过这里被优化掉了）
        fixed fadeOutEdge = saturate(1000.0 * (percentage - _DissolveFadeOutThreshold));  
        fixed3 fadeOutEdgeColor = lerp(_DissolveFadeMidColor.rgb, _DissolveFadeOutColor.rgb, fadeOutEdge);  
        // 设置 开始溶解->溶解颜色 的颜色过度
        fixed fadeMidAmount = saturate(1000.0 * (percentage - _DissolveFadeMidThreshold));  
        fixed3 fadeMidAmountColor = lerp(_DissolveFadeInColor.rgb, fadeOutEdgeColor.rgb, fadeMidAmount);  
        // 设置 源颜色->开始溶解 的颜色过度
        fixed fadeInEdge = saturate(1000.0 * (percentage - _DissolveFadeInThreshold));  
        resultColor.rgb = lerp(resultColor.rgb, fadeMidAmountColor, fadeInEdge);  
    #endif
    return resultColor;
}

float4 MainRoleTransparentFragment(v2f i) : SV_Target
{
    float4 mainColor = tex2D(_MainTex, i.uv);
    #if defined(_USE_DISSOLVE_EFFECT)
        // 不满足阈值的片元直接舍弃
        #if defined (_USE_DISSOLVE_MAP)
            float2 dissolve_uv = TRANSFORM_TEX(i.uv, _DissolveMap);
            fixed4 dissolveValue = tex2D(_DissolveMap, dissolve_uv); 
            if (dissolveValue.r < _DissolveThreshold)  
        #else
            if (mainColor.r < _DissolveThreshold)  
        #endif
        {  
            discard;  
        }  
    #endif

    float3 diffuse_fac = _SunColor + _AmbientColor.xyz;
    float3 diffuse = mainColor.rgb * 0.5 * 1.2784 * diffuse_fac;

    float3 N = normalize(i.normalDir);
    float3 L = i.dir_shadow.xyz;

    float4 resultColor;
    float3 V = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
    float NdotView = clamp(dot(N, V), 0.0, 1.0);
    float NdotshadowFactor = clamp(dot(L, N), 0.0, 1.0);
    float RimlightDotValue = clamp(dot(i.dir_rimlight, N), 0.0, 1.0);
    float Ndotshadow = smoothstep(_Shadownol1, _Shadownol2, NdotshadowFactor);

    float dif_illum = dot(diffuse, float3(0.299, 0.587, 0.114));
    float shadowshift = smoothstep(0.25, 0.74, dif_illum);
    float3 shadowColor = lerp(_DarkShadow.rgb, _BrightShadow.rgb, shadowshift);
    float3 baseColor = lerp(shadowColor * diffuse.rgb, diffuse.rgb, Ndotshadow);

    float rimdot = clamp(RimlightDotValue * (1.0 - NdotView), 0.0, 1.0);
    float rimffcal = smoothstep(0.35, 0.58, rimdot);
    float3 rim = rimffcal * diffuse * _RimColor.rgb;

    resultColor.rgb = baseColor + rim;
    float3 maskTemp = tex2D(_Mask, i.uv).rgb;
    float2 matcapuv = mul((float3x3)UNITY_MATRIX_V, N).xy;
    matcapuv.y = -matcapuv.y;
    matcapuv = matcapuv * 0.5 + 0.5;
    float3 matColor1 = tex2D(_MatcapTex, float2(matcapuv.x * 0.5, matcapuv.y)).rgb;
    float3 matColor2 = tex2D(_MatcapTex, float2(matcapuv.x * 0.5 + 0.5, matcapuv.y)).rgb;

    float matColor = (matColor1 * maskTemp.x * _MatcapScale1 + matColor2 * maskTemp.y * _MatcapScale2);

    resultColor.rgb += (matColor * diffuse + maskTemp.z * diffuse);
    resultColor.a = mainColor.a;
    resultColor *= _Color;

    #if defined(_USE_DISSOLVE_EFFECT)
        // 溶解相关
        // percentage 讲道理不会大于1的，大于1的情况上面就被迪斯咯的了，但pectange的整体趋势是随着_DissolveThreshold增加而增加这个是肯定的
        #if defined (_USE_DISSOLVE_MAP)
            fixed percentage = _DissolveThreshold / max(dissolveValue.r, 0.0001);  
        #else
            fixed percentage = _DissolveThreshold / max(mainColor.r, 0.0001);  
        #endif
        // 设置 溶解颜色->完全消融 的颜色过度
        // sign 根据范围返回一个标志，分别是小于0时返回-1，大于0时返回1，否则返回0（不过这里被优化掉了）
        fixed fadeOutEdge = saturate(1000.0 * (percentage - _DissolveFadeOutThreshold));  
        fixed3 fadeOutEdgeColor = lerp(_DissolveFadeMidColor.rgb, _DissolveFadeOutColor.rgb, fadeOutEdge);  
        // 设置 开始溶解->溶解颜色 的颜色过度
        fixed fadeMidAmount = saturate(1000.0 * (percentage - _DissolveFadeMidThreshold));  
        fixed3 fadeMidAmountColor = lerp(_DissolveFadeInColor.rgb, fadeOutEdgeColor.rgb, fadeMidAmount);  
        // 设置 源颜色->开始溶解 的颜色过度
        fixed fadeInEdge = saturate(1000.0 * (percentage - _DissolveFadeInThreshold));  
        resultColor.rgb = lerp(resultColor.rgb, fadeMidAmountColor, fadeInEdge);  
    #endif
    return resultColor;
}

float SampleNoiseMap(float2 uv)
{
    return tex2D(_HologramGlitchMap, uv).r;
}

float4 MainRoleHologramMaskFragment(v2f_hg i) : SV_Target
{
    return 1;
}

float4 MainRoleHologramFragment(v2f_hg i) : SV_Target
{
    float4 main_color = _HologramColor;
    // 用主纹理的r通道做颜色蒙版
    float2 mask_uv = i.uv.xy * _HologramMaskMap_ST.xy + _HologramMaskMap_ST.zw;
    float4 mask = tex2D(_HologramMaskMap, mask_uv);
    float mask_alpha = lerp(1, mask.b, _HologramMaskAffect);
    #if defined(_USE_DISSOLVE_EFFECT)
        // 不满足阈值的片元直接舍弃
        #if defined (_USE_DISSOLVE_MAP)
            float2 dissolve_uv = TRANSFORM_TEX(i.uv, _DissolveMap);
            fixed4 dissolveValue = tex2D(_DissolveMap, dissolve_uv); 
            if (dissolveValue.r < _DissolveThreshold)  
        #else
            if (mask_alpha < _DissolveThreshold)  
        #endif
        {  
            discard;  
        }  
    #endif
    // 全息颜色故障效果处理
    float color_glicth_noise = SampleNoiseMap(float2(_Time.x * _HologramColorGlitchData.x, _Time.x * _HologramColorGlitchData.y));
    color_glicth_noise = color_glicth_noise * (1.0 - _HologramColorGlitchMin) + _HologramColorGlitchMin;
    color_glicth_noise = clamp(color_glicth_noise, 0.0, 1.0);
    float color_glitch = lerp(1.0, color_glicth_noise, _HologramColorGlitch * _HologramColorGlitchTog);
    // 菲涅尔反射
    float3 w_viewDir = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);;
    float3 w_normal = normalize(i.normalDir);
    float nDotV = dot(w_normal, w_viewDir);
    float rim_nDotV = 1.0 - nDotV;
    float fresnel = _FresnelScale * pow(rim_nDotV, _FresnelPower);
    float fresnel_alpha = clamp(_FresnelAlphaScale * pow(rim_nDotV, _FresnelAlphaPower), 0.0, 1.0);
    float4 fresnel_color = (float4(fresnel, fresnel, fresnel, 1.0) * float4(main_color.rgb, 1.0)) * fresnel_alpha;

    float3 mask_color = tex2D(_MainTex, i.uv).r;
    
    // 全息效果 扫描线
    float2 line1_uv = (i.posWorld.y * _HologramLine1Frequency + _Time.y * _HologramLine1Speed).xx;
    float line1 = clamp(tex2D(_HologramLine1, line1_uv).r, 0.0, 1.0);
    float4 line1_color = float4((main_color * line1).rgb, line1) * _HologramLine1Alpha;
    float line1_alpha = clamp(((main_color).a + (line1_color).w), 0.0 , 1.0);

    #if defined (_USE_SCANLINE2)
        float2 line2_uv = (i.posWorld.y * _HologramLine2Frequency + _Time.y * _HologramLine2Speed).xx;
        float line2 = clamp(tex2D(_HologramLine2, line2_uv).r, 0.0, 1.0);
        float4 line2_color = float4((main_color * line2).rgb, line2) * _HologramLine2Alpha;
        float line2_alpha = clamp(((main_color).a + (line2_color).w), 0.0 , 1.0);
    #else
        float4 line2_color = 0.0;
        float line2_alpha = 1.0;
    #endif
    // Grain 颗粒效果
    float grain_noise = SampleNoiseMap((i.posWorld.xy * _HologramGrainData.xy + _Time.y * _HologramGrainSpeed));
    float lerp_val = lerp(_HologramGrainData.z, _HologramGrainData.w, grain_noise);
    float grain_amount = lerp(0.0, lerp_val, _HologramGrainAffect);

    float4 resultColor = float4(
        ((main_color + fresnel_color + float4(line1_color.xyz + line2_color.xyz, 0.0) + grain_amount)).rgb, 
        (line1_alpha * line2_alpha * mask_alpha * _HologramAlpha)) * color_glitch;

    #if defined(_USE_DISSOLVE_EFFECT)
        // 溶解相关
        // percentage 讲道理不会大于1的，大于1的情况上面就被迪斯咯的了，但pectange的整体趋势是随着_DissolveThreshold增加而增加这个是肯定的
        #if defined (_USE_DISSOLVE_MAP)
            fixed percentage = _DissolveThreshold / max(dissolveValue.r, 0.0001);  
        #else
            fixed percentage = _DissolveThreshold / max(mask_alpha, 0.0001);  
        #endif
        // 设置 溶解颜色->完全消融 的颜色过度
        // sign 根据范围返回一个标志，分别是小于0时返回-1，大于0时返回1，否则返回0（不过这里被优化掉了）
        fixed fadeOutEdge = saturate(1000.0 * (percentage - _DissolveFadeOutThreshold));  
        fixed3 fadeOutEdgeColor = lerp(_DissolveFadeMidColor.rgb, _DissolveFadeOutColor.rgb, fadeOutEdge);  
        // 设置 开始溶解->溶解颜色 的颜色过度
        fixed fadeMidAmount = saturate(1000.0 * (percentage - _DissolveFadeMidThreshold));  
        fixed3 fadeMidAmountColor = lerp(_DissolveFadeInColor.rgb, fadeOutEdgeColor.rgb, fadeMidAmount);  
        // 设置 源颜色->开始溶解 的颜色过度
        fixed fadeInEdge = saturate(1000.0 * (percentage - _DissolveFadeInThreshold));  
        resultColor.rgb = lerp(resultColor.rgb, fadeMidAmountColor, fadeInEdge);  
    #endif
    float mask_use_axis = i.mPos[(uint)_HologramMaskUseAxis];
    float mask_lerp_amount = mask_use_axis - _HologramYMask;
    resultColor.a = clamp(lerp(resultColor.a, 0, mask_lerp_amount), 0.0, resultColor.a);
    return resultColor;
}

v2f_hg CombineHologramAndAlphaTextureVertex(a2v_hg v)
{
    v2f_hg o;
    #if defined(_USE_DISSOLVE_EFFECT)
        // 产生模型顶点方向上的扭曲系数
        float mask_use_axis = v.vertex[(uint)_HologramMaskUseAxis];
        fixed dir = -2 * _ReverseDissolveDirection + 1;
        float height_progressMid = lerp(_ModelHeightButton, _ModelHeightTop, _DissolveThreshold);
        float fadeMidAmount = saturate(1000.0 * (dir * mask_use_axis - height_progressMid));  // * 1000的作用是优化掉sign，避免可能产生的编译分支问题
        fixed vertex_amount = lerp(1.0, 0.0, fadeMidAmount); 
        v.vertex.xyz += vertex_amount * VertexHologramOffset(v.vertex.xyz, _HologramGliterData1);
        v.vertex.xyz += vertex_amount * VertexHologramOffset(v.vertex.xyz, _HologramGliterData2);
    #else
        v.vertex.xyz += VertexHologramOffset(v.vertex.xyz, _HologramGliterData1);
        v.vertex.xyz += VertexHologramOffset(v.vertex.xyz, _HologramGliterData2);
    #endif

    o.mPos = v.vertex;
    o.posWorld = mul(unity_ObjectToWorld, v.vertex);
    o.pos = mul(UNITY_MATRIX_VP, o.posWorld);
    o.uv = v.uv;
    o.normalDir = mul((float3x3)unity_ObjectToWorld, v.normal);

    return o;
}

float4 CombineHologramAndAlphaTextureFragment(v2f_hg i) : SV_Target
{
    float4 main_color = _HologramColor;
    // 用主纹理的r通道做全息颜色蒙版
    float2 mask_uv = i.uv.xy * _HologramMaskMap_ST.xy + _HologramMaskMap_ST.zw;
    float4 mask = tex2D(_HologramMaskMap, mask_uv);
    float channel_max = max(max(mask.r, mask.g), mask.b);
    float mask_alpha = lerp(1, channel_max, _HologramMaskAffect);
    #if defined(_USE_DISSOLVE_EFFECT) || defined (_USE_DISSOLVE_MAP)
        float2 dissolve_uv = TRANSFORM_TEX(i.uv, _DissolveMap);
        fixed4 dissolveValue = tex2D(_DissolveMap, dissolve_uv); 
    #endif
    // 全息颜色故障效果处理
    float color_glicth_noise = SampleNoiseMap(float2(_Time.x * _HologramColorGlitchData.x, _Time.x * _HologramColorGlitchData.y));
    color_glicth_noise = color_glicth_noise * (1.0 - _HologramColorGlitchMin) + _HologramColorGlitchMin;
    color_glicth_noise = clamp(color_glicth_noise, 0.0, 1.0);
    float color_glitch = lerp(1.0, color_glicth_noise, _HologramColorGlitch * _HologramColorGlitchTog);
    // 菲涅尔反射
    float3 w_viewDir = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);;
    float3 w_normal = normalize(i.normalDir);
    float nDotV = dot(w_normal, w_viewDir);
    float rim_nDotV = 1.0 - nDotV;
    float fresnel = _FresnelScale * pow(rim_nDotV, _FresnelPower);
    float fresnel_alpha = clamp(_FresnelAlphaScale * pow(rim_nDotV, _FresnelAlphaPower), 0.0, 1.0);
    float4 fresnel_color = (float4(fresnel, fresnel, fresnel, 1.0) * float4(main_color.rgb, 1.0)) * fresnel_alpha;

    float3 mask_color = tex2D(_MainTex, i.uv).r;
    
    // 全息效果 扫描线
    float2 line1_uv = (i.posWorld.y * _HologramLine1Frequency + _Time.y * _HologramLine1Speed).xx;
    float line1 = clamp(tex2D(_HologramLine1, line1_uv).r, 0.0, 1.0);
    float4 line1_color = float4((main_color * line1).rgb, line1) * _HologramLine1Alpha;
    float line1_alpha = clamp(((main_color).a + (line1_color).w), 0.0 , 1.0);

    #if defined (_USE_SCANLINE2)
        float2 line2_uv = (i.posWorld.y * _HologramLine2Frequency + _Time.y * _HologramLine2Speed).xx;
        float line2 = clamp(tex2D(_HologramLine2, line2_uv).r, 0.0, 1.0);
        float4 line2_color = float4((main_color * line2).rgb, line2) * _HologramLine2Alpha;
        float line2_alpha = clamp(((main_color).a + (line2_color).w), 0.0 , 1.0);
    #else
        float4 line2_color = 0.0;
        float line2_alpha = 1.0;
    #endif
    // Grain 颗粒效果
    float grain_noise = SampleNoiseMap((i.posWorld.xy * _HologramGrainData.xy + _Time.y * _HologramGrainSpeed));
    float lerp_val = lerp(_HologramGrainData.z, _HologramGrainData.w, grain_noise);
    float grain_amount = lerp(0.0, lerp_val, _HologramGrainAffect);

    float4 hologram_color = float4(
        ((main_color + fresnel_color + float4(line1_color.xyz + line2_color.xyz, 0.0) + grain_amount)).rgb, 
        (line1_alpha * line2_alpha * mask_alpha * _HologramAlpha)) * color_glitch;

    // 提前获取最终蒙版轴向
    float mask_use_axis = i.mPos[(uint)_HologramMaskUseAxis];
    // 处理最终颜色
    fixed4 final_color;
    final_color.a = hologram_color.a;
    #if defined(_USE_DISSOLVE_EFFECT)
        // 溶解相关
        float height_allout = lerp(_ModelHeightButton, _ModelHeightTop, _DissolveThreshold - 2 * _DissolveFadeGap);
        float height_progressOut = lerp(_ModelHeightButton, _ModelHeightTop, _DissolveThreshold - _DissolveFadeGap);
        float height_progressMid = lerp(_ModelHeightButton, _ModelHeightTop, _DissolveThreshold);
        float height_progressIn = lerp(_ModelHeightButton, _ModelHeightTop, _DissolveThreshold + _DissolveFadeGap);
        // 设置完全消融 -> alphaTexture颜色过度
        fixed dir = -2 * _ReverseDissolveDirection + 1;
        fixed fadeAllOut = saturate(1000.0 * (dir * mask_use_axis - height_allout));  // * 1000的作用是优化掉sign，避免可能产生的编译分支问题
        fixed3 fadeAllOutColor = lerp(_DissolveFadeOutColor.rgb, mask.rgb * _AlphaTexColor.rgb, fadeAllOut); 
        final_color.a = lerp(final_color.a, 1, fadeAllOut);  // 处理透明度，但不要影响到全息的透明度
        // 设置 溶解颜色->完全消融 的颜色过度
        // sign 根据范围返回一个标志，分别是小于0时返回-1，大于0时返回1，否则返回0（不过这里被优化掉了）
        fixed fadeOutEdge = saturate(1000.0 * (dir * mask_use_axis - height_progressOut));  
        fixed3 fadeOutEdgeColor = lerp(_DissolveFadeMidColor.rgb, fadeAllOutColor.rgb, fadeOutEdge);  
        // 设置 开始溶解->溶解颜色 的颜色过度
        fixed fadeMidAmount = saturate(1000.0 * (dir * mask_use_axis - height_progressMid));  
        fixed3 fadeMidAmountColor = lerp(_DissolveFadeInColor.rgb, fadeOutEdgeColor.rgb, fadeMidAmount);  
        // 设置 源颜色->开始溶解 的颜色过度
        fixed fadeInEdge = saturate(1000.0 * (dir * mask_use_axis - height_progressIn));  
        hologram_color.rgb = lerp(hologram_color.rgb, fadeMidAmountColor, fadeInEdge);  

    #endif
    
    // 轴向淡出，不受任何上述效果的影响，直接裁剪掉alpha值
    float mask_lerp_amount = mask_use_axis - _HologramYMask;
    final_color.a = clamp(lerp(final_color.a, 0, mask_lerp_amount), 0.0, final_color.a);
    // 预乘透明度
    final_color.rgb = hologram_color.rgb * final_color.a;
    return final_color;
}

#endif // MAINROLE_EFFECT_CG_INCLUDED