// SPDX-License-Identifier: (Not available for this version, you are only allowed to use this software if you have express permission from the copyright holder and agreed to the latest NiloToonURP EULA)
// Copyright (c) 2021 Kuroneko ShaderLab Limited

// For more information, visit -> https://github.com/ColinLeung-NiloCat/UnityURPToonLitShaderExample

// This shader is a direct copy of Unity6.1 URP17.0.3's LitForwardPass.hlsl, but with some edit.
// If you want to see what is the difference, all edited lines will have a [NiloToon] tag, you can search [NiloToon] in this file,
// or compare Unity6.1 URP17.0.3's LitForwardPass.hlsl with this file using tools like SourceGear DiffMerge.

// #pragma once is a safeguard best practice in almost every .hlsl, 
// doing this can make sure your .hlsl's user can include this .hlsl anywhere anytime without producing any multi include conflict
#pragma once

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
#if UNITY_VERSION >= 202220
#if defined(LOD_FADE_CROSSFADE)
    #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/LODCrossFade.hlsl"
#endif
#endif

// [NiloToon] add:
//==========================================================================================================
// + Rider code highlight support for all shader_feature and multi_compile
// (__RESHARPER__ is only defined while in IDE. Used to help editing this file with proper highlighting.)
#ifdef __RESHARPER__
#define _NILOTOON_GLOBAL_ENABLE_SCREENSPACE_OUTLINE 1
#define _NILOTOON_GLOBAL_ENABLE_SCREENSPACE_OUTLINE_V2 1
#define _SPLATMAP 1
#define _RECEIVE_NILOTOON_CHAR_SHADOW 1
#define _NILOTOON_RECEIVE_SELF_SHADOW 1
#endif

#include "../../ShaderLibrary/NiloUtilityHLSL/NiloAllUtilIncludes.hlsl"

#if defined(_SPLATMAP)
    #if !defined(_NORMALMAP)
        #define _NORMALMAP
    #endif
#endif
//==========================================================================================================

#if defined(_PARALLAXMAP)
#define REQUIRES_TANGENT_SPACE_VIEW_DIR_INTERPOLATOR
#endif

#if (defined(_NORMALMAP) || (defined(_PARALLAXMAP) && !defined(REQUIRES_TANGENT_SPACE_VIEW_DIR_INTERPOLATOR))) || defined(_DETAIL)
#define REQUIRES_WORLD_SPACE_TANGENT_INTERPOLATOR
#endif

// keep this file in sync with LitGBufferPass.hlsl

struct Attributes
{
    float4 positionOS   : POSITION;
    float3 normalOS     : NORMAL;
    float4 tangentOS    : TANGENT;
    float2 texcoord     : TEXCOORD0;
    float2 staticLightmapUV   : TEXCOORD1;
    float2 dynamicLightmapUV  : TEXCOORD2;
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

struct Varyings
{
    float2 uv                       : TEXCOORD0;

#if defined(REQUIRES_WORLD_SPACE_POS_INTERPOLATOR)
    float3 positionWS               : TEXCOORD1;
#endif

    float3 normalWS                 : TEXCOORD2;
#if defined(REQUIRES_WORLD_SPACE_TANGENT_INTERPOLATOR)
    half4 tangentWS                : TEXCOORD3;    // xyz: tangent, w: sign
#endif

#if UNITY_VERSION < 202220
    float3 viewDirWS                : TEXCOORD4;
#endif

#ifdef _ADDITIONAL_LIGHTS_VERTEX
    half4 fogFactorAndVertexLight   : TEXCOORD5; // x: fogFactor, yzw: vertex light
#else
    half  fogFactor                 : TEXCOORD5;
#endif

#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
    float4 shadowCoord              : TEXCOORD6;
#endif

#if defined(REQUIRES_TANGENT_SPACE_VIEW_DIR_INTERPOLATOR)
    half3 viewDirTS                : TEXCOORD7;
#endif

    DECLARE_LIGHTMAP_OR_SH(staticLightmapUV, vertexSH, 8);
#ifdef DYNAMICLIGHTMAP_ON
    float2  dynamicLightmapUV : TEXCOORD9; // Dynamic lightmap UVs
#endif

#ifdef USE_APV_PROBE_OCCLUSION
    float4 probeOcclusion : TEXCOORD10;
#endif
    
    // [NiloToon] add:
    //=======================================================
    float4 screenPos                : TEXCOORD11;
    //=======================================================

    float4 positionCS               : SV_POSITION;
    UNITY_VERTEX_INPUT_INSTANCE_ID
    UNITY_VERTEX_OUTPUT_STEREO
};

void InitializeInputData(Varyings input, half3 normalTS, out InputData inputData)
{
    inputData = (InputData)0;

#if defined(REQUIRES_WORLD_SPACE_POS_INTERPOLATOR)
    inputData.positionWS = input.positionWS;
#endif

#if UNITY_VERSION >= 60000000
#if defined(DEBUG_DISPLAY)
    inputData.positionCS = input.positionCS;
#endif
#endif

    half3 viewDirWS = GetWorldSpaceNormalizeViewDir(input.positionWS);
#if defined(_NORMALMAP) || defined(_DETAIL)
    float sgn = input.tangentWS.w;      // should be either +1 or -1
    float3 bitangent = sgn * cross(input.normalWS.xyz, input.tangentWS.xyz);
    half3x3 tangentToWorld = half3x3(input.tangentWS.xyz, bitangent.xyz, input.normalWS.xyz);

    #if defined(_NORMALMAP)
    inputData.tangentToWorld = tangentToWorld;
    #endif
    inputData.normalWS = TransformTangentToWorld(normalTS, tangentToWorld);
#else
    inputData.normalWS = input.normalWS;
#endif

    inputData.normalWS = NormalizeNormalPerPixel(inputData.normalWS);
    inputData.viewDirectionWS = viewDirWS;

#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
    inputData.shadowCoord = input.shadowCoord;
#elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
    inputData.shadowCoord = TransformWorldToShadowCoord(inputData.positionWS);
#else
    inputData.shadowCoord = float4(0, 0, 0, 0);
#endif
#ifdef _ADDITIONAL_LIGHTS_VERTEX
    inputData.fogCoord = InitializeInputDataFog(float4(input.positionWS, 1.0), input.fogFactorAndVertexLight.x);
    inputData.vertexLighting = input.fogFactorAndVertexLight.yzw;
#else
    inputData.fogCoord = InitializeInputDataFog(float4(input.positionWS, 1.0), input.fogFactor);
#endif

#if UNITY_VERSION < 60000000
#if defined(DYNAMICLIGHTMAP_ON)
    inputData.bakedGI = SAMPLE_GI(input.staticLightmapUV, input.dynamicLightmapUV, input.vertexSH, inputData.normalWS);
#elif !defined(LIGHTMAP_ON) && (defined(PROBE_VOLUMES_L1) || defined(PROBE_VOLUMES_L2))
    inputData.bakedGI = SAMPLE_GI(input.vertexSH,
        GetAbsolutePositionWS(inputData.positionWS),
        inputData.normalWS,
        inputData.viewDirectionWS,
        input.positionCS.xy);
#else
    inputData.bakedGI = SAMPLE_GI(input.staticLightmapUV, input.vertexSH, inputData.normalWS);
#endif
#endif

    inputData.normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(input.positionCS);
    
#if UNITY_VERSION < 60000000
    inputData.shadowMask = SAMPLE_SHADOWMASK(input.staticLightmapUV);
#endif

    #if defined(DEBUG_DISPLAY)
    #if defined(DYNAMICLIGHTMAP_ON)
    inputData.dynamicLightmapUV = input.dynamicLightmapUV;
    #endif
    #if defined(LIGHTMAP_ON)
    inputData.staticLightmapUV = input.staticLightmapUV;
    #else
    inputData.vertexSH = input.vertexSH;
    #endif
    #if UNITY_VERSION >= 60000000
    #if defined(USE_APV_PROBE_OCCLUSION)
    inputData.probeOcclusion = input.probeOcclusion;
    #endif
    #endif
    #endif
}

#if UNITY_VERSION >= 60000000
void InitializeBakedGIData(Varyings input, inout InputData inputData)
{
    #if defined(DYNAMICLIGHTMAP_ON)
    inputData.bakedGI = SAMPLE_GI(input.staticLightmapUV, input.dynamicLightmapUV, input.vertexSH, inputData.normalWS);
    inputData.shadowMask = SAMPLE_SHADOWMASK(input.staticLightmapUV);
    #elif !defined(LIGHTMAP_ON) && (defined(PROBE_VOLUMES_L1) || defined(PROBE_VOLUMES_L2))
    inputData.bakedGI = SAMPLE_GI(input.vertexSH,
        GetAbsolutePositionWS(inputData.positionWS),
        inputData.normalWS,
        inputData.viewDirectionWS,
        input.positionCS.xy,
        input.probeOcclusion,
        inputData.shadowMask);
    #else
    inputData.bakedGI = SAMPLE_GI(input.staticLightmapUV, input.vertexSH, inputData.normalWS);
    inputData.shadowMask = SAMPLE_SHADOWMASK(input.staticLightmapUV);
    #endif
}
#endif

// [NiloToon] add:
//==========================================================================================================================================================
// debug on off
float _NiloToonGlobalEnviMinimumShader;

// shadow boader color
float4 _NiloToonGlobalEnviShadowBorderTintColor;

// global GI edit
float3 _NiloToonGlobalEnviGITintColor;
float3 _NiloToonGlobalEnviGIAddColor;

// global GI override
float4 _NiloToonGlobalEnviGIOverride;

// global albedo override
float4 _NiloToonGlobalEnviAlbedoOverrideColor;

// global surface color result override
float4 _NiloToonGlobalEnviSurfaceColorResultOverrideColor;

// global screen space outline settings
float _GlobalScreenSpaceOutlineIntensityForEnvi;
float _GlobalScreenSpaceOutlineWidthMultiplierForEnvi;
float _GlobalScreenSpaceOutlineNormalsSensitivityOffsetForEnvi;
float _GlobalScreenSpaceOutlineDepthSensitivityOffsetForEnvi;
float _GlobalScreenSpaceOutlineDepthSensitivityDistanceFadeoutStrengthForEnvi;
half3 _GlobalScreenSpaceOutlineTintColorForEnvi;

// global screen space outline V2 settings
float _GlobalScreenSpaceOutlineV2IntensityForEnvi;
float _GlobalScreenSpaceOutlineV2WidthMultiplierForEnvi;
float _GlobalScreenSpaceOutlineV2EnableGeometryEdgeForEnvi;
float _GlobalScreenSpaceOutlineV2GeometryEdgeThresholdForEnvi;
float _GlobalScreenSpaceOutlineV2EnableNormalAngleEdgeForEnvi;
float _GlobalScreenSpaceOutlineV2NormalAngleCosThetaThresholdForEnvi;

// global camera uniforms
float _CurrentCameraFOV;

// NiloToon Character Self Shadow uniforms and texture
#if defined(_RECEIVE_NILOTOON_CHAR_SHADOW) && defined(_NILOTOON_RECEIVE_SELF_SHADOW)
TEXTURE2D(_NiloToonCharSelfShadowMapRT);
SAMPLER_CMP(sampler_NiloToonCharSelfShadowMapRT_LinearClampCompare);
SAMPLER(sampler_NiloToonCharSelfShadowMapRT_Linear_Clamp); // for raw depth sampling

float4x4 _NiloToonSelfShadowWorldToClip;
float4 _NiloToonSelfShadowParam;           // (1/w, 1/h, w, h)
float3 _NiloToonSelfShadowLightDirection;
float _GlobalReceiveNiloToonSelfShadowMap;
float _NiloToonSelfShadowRange;
float _NiloToonSelfShadowUseNdotLFix;
float _NiloToonCharShadowStrength;         // per-material shadow strength
#endif

// include files, include as late as possible to get all defines
#include "NiloToonEnvironment_ExtendFunctionsForUserCustomLogic.hlsl"

// NiloToon Character Self Shadow sampling function
#if defined(_RECEIVE_NILOTOON_CHAR_SHADOW) && defined(_NILOTOON_RECEIVE_SELF_SHADOW)
half SampleNiloToonCharSelfShadow(float3 positionWS, float3 normalWS, float linearEyeDepth)
{
    // Transform world position to shadow map clip space
    float4 positionSelfShadowCS = mul(_NiloToonSelfShadowWorldToClip, float4(positionWS, 1));
    float3 positionSelfShadowNDC = positionSelfShadowCS.xyz;

    // Convert NDC.xy[-1,1] to UV[0,1]
    float2 shadowMapUV = positionSelfShadowNDC.xy * 0.5 + 0.5;

    // Calculate compare value for shadow test
    float ndcZCompareValue = positionSelfShadowNDC.z;

    // If OpenGL, convert NDC.z[-1,1] to [0,1], because shadowmap uses [0,1] range
    // If DirectX, it's already [0,1]
    ndcZCompareValue = UNITY_NEAR_CLIP_VALUE < 0 ? ndcZCompareValue * 0.5 + 0.5 : ndcZCompareValue;

    // If DirectX, flip shadowMapUV.y (y = 1-y)
    // If OpenGL, do nothing
    #if UNITY_UV_STARTS_AT_TOP
    shadowMapUV.y = 1 - shadowMapUV.y;
    #endif

    // Check if outside shadow map UV bounds - no shadow outside
    if(shadowMapUV.x < 0 || shadowMapUV.x > 1 || shadowMapUV.y < 0 || shadowMapUV.y > 1)
    {
        return 1; // no shadow
    }

    // Sample raw depth from shadow map to check if this is an empty area (no character)
    // Empty areas have depth = 0 (cleared value), which would incorrectly cause shadow
    float shadowMapRawDepth = SAMPLE_TEXTURE2D_LOD(_NiloToonCharSelfShadowMapRT,
                                sampler_NiloToonCharSelfShadowMapRT_Linear_Clamp,
                                shadowMapUV, 0).r;

    // If shadowmap depth is near 0 (empty area - no character rendered there), no shadow
    // In reverse-Z, 0 = far plane (empty/cleared), values closer to 1 = actual geometry
    if(shadowMapRawDepth < 0.0001)
    {
        return 1; // no shadow - empty area in shadow map
    }

    // Pack UV and compare value for SAMPLE_TEXTURE2D_SHADOW
    float4 selfShadowmapUV = float4(shadowMapUV, ndcZCompareValue, 0);

    // Sample shadow map with depth comparison (hardware 1-tap bilinear filter)
    half shadow = SAMPLE_TEXTURE2D_SHADOW(_NiloToonCharSelfShadowMapRT,
                    sampler_NiloToonCharSelfShadowMapRT_LinearClampCompare,
                    selfShadowmapUV.xyz);

    // Fadeout shadow if reaching the end of shadow distance
    float fadeTotalDistance = 1.0;
    shadow = lerp(shadow, 1, saturate((1.0 / fadeTotalDistance) * (linearEyeDepth - (_NiloToonSelfShadowRange - fadeTotalDistance))));

    // Use N dot L fix to hide shadow acne on surfaces facing away from light
    if(_NiloToonSelfShadowUseNdotLFix > 0.5)
    {
        shadow *= smoothstep(0.1, 0.2, saturate(dot(normalWS, _NiloToonSelfShadowLightDirection)));
    }

    return shadow;
}
#endif
//==========================================================================================================================================================

///////////////////////////////////////////////////////////////////////////////
//                  Vertex and Fragment functions                            //
///////////////////////////////////////////////////////////////////////////////

// Used in Standard (Physically Based) shader
Varyings LitPassVertex(Attributes input)
{
    Varyings output = (Varyings)0;

    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_TRANSFER_INSTANCE_ID(input, output);
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

    // [NiloToon] add:
    //==========================================================================================================================================================
    ApplyCustomUserLogicToVertexAttributeAtVertexShaderStart(input);
    //==========================================================================================================================================================
    
    VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);

    // normalWS and tangentWS already normalize.
    // this is required to avoid skewing the direction during interpolation
    // also required for per-vertex lighting and SH evaluation
    VertexNormalInputs normalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);

    half3 vertexLight = VertexLighting(vertexInput.positionWS, normalInput.normalWS);

    half fogFactor = 0;
    #if !defined(_FOG_FRAGMENT)
        fogFactor = ComputeFogFactor(vertexInput.positionCS.z);
    #endif

    output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);

    // already normalized from normal transform to WS.
    output.normalWS = normalInput.normalWS;
#if defined(REQUIRES_WORLD_SPACE_TANGENT_INTERPOLATOR) || defined(REQUIRES_TANGENT_SPACE_VIEW_DIR_INTERPOLATOR)
    real sign = input.tangentOS.w * GetOddNegativeScale();
    half4 tangentWS = half4(normalInput.tangentWS.xyz, sign);
#endif
#if defined(REQUIRES_WORLD_SPACE_TANGENT_INTERPOLATOR)
    output.tangentWS = tangentWS;
#endif

#if defined(REQUIRES_TANGENT_SPACE_VIEW_DIR_INTERPOLATOR)
    half3 viewDirWS = GetWorldSpaceNormalizeViewDir(vertexInput.positionWS);
    half3 viewDirTS = GetViewDirectionTangentSpace(tangentWS, output.normalWS, viewDirWS);
    output.viewDirTS = viewDirTS;
#endif

    OUTPUT_LIGHTMAP_UV(input.staticLightmapUV, unity_LightmapST, output.staticLightmapUV);
#ifdef DYNAMICLIGHTMAP_ON
    output.dynamicLightmapUV = input.dynamicLightmapUV.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
#endif

    #if UNITY_VERSION >= 60000011
    OUTPUT_SH4(vertexInput.positionWS, output.normalWS.xyz, GetWorldSpaceNormalizeViewDir(vertexInput.positionWS), output.vertexSH, output.probeOcclusion);
    #elif UNITY_VERSION >= 202310
    OUTPUT_SH4(vertexInput.positionWS, output.normalWS.xyz, GetWorldSpaceNormalizeViewDir(vertexInput.positionWS), output.vertexSH);
    #else
    OUTPUT_SH(output.normalWS.xyz, output.vertexSH);
    #endif

#ifdef _ADDITIONAL_LIGHTS_VERTEX
    output.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
#else
    output.fogFactor = fogFactor;
#endif

#if defined(REQUIRES_WORLD_SPACE_POS_INTERPOLATOR)
    output.positionWS = vertexInput.positionWS;
#endif

#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
    output.shadowCoord = GetShadowCoord(vertexInput);
#endif

    output.positionCS = vertexInput.positionCS;

    // [NiloToon] add:
    //==========================================================================================================================================================
    output.screenPos = ComputeScreenPos(output.positionCS);

    ApplyCustomUserLogicToVertexShaderOutputAtVertexShaderEnd(output, input);
    //==========================================================================================================================================================
    return output;
}

// [NiloToon] add:
//==========================================================================================================================================================
half4 CalculateFinalSplatBlendFactor(half blendSoftness, half depth1, half depth2, half depth3, half depth4, half4 splatControlMapRGBA)
{
    half4 blend;
    
    blend.r = depth1 * splatControlMapRGBA.r;
    blend.g = depth2 * splatControlMapRGBA.g;
    blend.b = depth3 * splatControlMapRGBA.b;
    blend.a = depth4 * splatControlMapRGBA.a;
    
    half ma = max(blend.r, max(blend.g, max(blend.b, blend.a)));
    blend = max(blend - ma + max(0.001,blendSoftness), 0) * splatControlMapRGBA; // 0.001 is safer than 0.00001 when testing with different textures
    return blend/(blend.r + blend.g + blend.b + blend.a);
}
void ApplySplatMapToSurfaceData(inout SurfaceData surfaceData, Varyings input)
{
    // for reference see URP's TerrainLitPasses.hlsl -> SplatmapMix()
#if defined(_SPLATMAP)

    // uv
    float2 uvR = input.uv * _SplatAlbedoMapRTiling;
    float2 uvG = input.uv * _SplatAlbedoMapGTiling;
    float2 uvB = input.uv * _SplatAlbedoMapBTiling;
    float2 uvA = input.uv * _SplatAlbedoMapATiling;

    // sample packed data map (not yet apply mask)
    half4 packedDataR = SAMPLE_TEXTURE2D(_SplatPackedDataMapR, sampler_SplatPackedDataMap_linear_repeat, uvR);
    half4 packedDataG = SAMPLE_TEXTURE2D(_SplatPackedDataMapG, sampler_SplatPackedDataMap_linear_repeat, uvG);
    half4 packedDataB = SAMPLE_TEXTURE2D(_SplatPackedDataMapB, sampler_SplatPackedDataMap_linear_repeat, uvB);
    half4 packedDataA = SAMPLE_TEXTURE2D(_SplatPackedDataMapA, sampler_SplatPackedDataMap_linear_repeat, uvA);

    // get height from each type of material
    half heightR = packedDataR.b * _SplatHeightMultiplierR;
    half heightG = packedDataG.b * _SplatHeightMultiplierG;
    half heightB = packedDataB.b * _SplatHeightMultiplierB;
    half heightA = packedDataA.b * _SplatHeightMultiplierA;

    // sample and remap mask (using height from PackedDataMap)
    half4 mask = SAMPLE_TEXTURE2D(_SplatMaskMap, sampler_SplatMaskMap, input.uv);
    mask = CalculateFinalSplatBlendFactor(_SplatMaskBlendingSoftness,heightR,heightG,heightB,heightA,mask);

    // sample albedo + smoothness
    half4 albedoSmoothnessR = SAMPLE_TEXTURE2D(_SplatAlbedoMapR, sampler_SplatAlbedoMap_linear_repeat, uvR) * mask.r;
    half4 albedoSmoothnessG = SAMPLE_TEXTURE2D(_SplatAlbedoMapG, sampler_SplatAlbedoMap_linear_repeat, uvG) * mask.g;
    half4 albedoSmoothnessB = SAMPLE_TEXTURE2D(_SplatAlbedoMapB, sampler_SplatAlbedoMap_linear_repeat, uvB) * mask.b;
    half4 albedoSmoothnessA = SAMPLE_TEXTURE2D(_SplatAlbedoMapA, sampler_SplatAlbedoMap_linear_repeat, uvA) * mask.a;

    // apply albedo
    half3 albedoR = albedoSmoothnessR.rgb * _SplatAlbedoMapRTintColor;
    half3 albedoG = albedoSmoothnessG.rgb * _SplatAlbedoMapGTintColor;
    half3 albedoB = albedoSmoothnessB.rgb * _SplatAlbedoMapBTintColor;
    half3 albedoA = albedoSmoothnessA.rgb * _SplatAlbedoMapATintColor;
    surfaceData.albedo = lerp(surfaceData.albedo, albedoR + albedoG + albedoB + albedoA, _SplatMapFeatureOnOff);

    /*
    // apply metallic
    half metallicR = lerp(1,packedDataR.r,_SplatOverrideMetallicR) * mask.r;
    half metallicG = lerp(1,packedDataG.r,_SplatOverrideMetallicG) * mask.g;
    half metallicB = lerp(1,packedDataB.r,_SplatOverrideMetallicB) * mask.b;
    half metallicA = lerp(1,packedDataA.r,_SplatOverrideMetallicA) * mask.a;
    surfaceData.metallic = lerp(surfaceData.metallic, metallicR + metallicG + metallicB + metallicA, _SplatMapFeatureOnOff);

    // apply occlusion
    half occlusionR = packedDataR.g * mask.r;
    half occlusionG = packedDataG.g * mask.g;
    half occlusionB = packedDataB.g * mask.b;
    half occlusionA = packedDataA.g * mask.a;
    surfaceData.occlusion = lerp(surfaceData.occlusion, occlusionR + occlusionG + occlusionB + occlusionA, _SplatMapFeatureOnOff);
    */

    // apply smoothness
    half smoothnessR = saturate(albedoSmoothnessR.a * _SplatSmoothnessMultiplierR);
    half smoothnessG = saturate(albedoSmoothnessG.a * _SplatSmoothnessMultiplierG);
    half smoothnessB = saturate(albedoSmoothnessB.a * _SplatSmoothnessMultiplierB);
    half smoothnessA = saturate(albedoSmoothnessA.a * _SplatSmoothnessMultiplierA);
    surfaceData.smoothness = lerp(surfaceData.smoothness, smoothnessR + smoothnessG + smoothnessB + smoothnessA, _SplatMapFeatureOnOff);

    // sample and apply normal
    half3 normalTSR = UnpackNormalScale(SAMPLE_TEXTURE2D(_SplatNormalMapR, sampler_SplatNormalMap_linear_repeat, uvR),_SplatNormalMapIntensityR) * mask.r;
    half3 normalTSG = UnpackNormalScale(SAMPLE_TEXTURE2D(_SplatNormalMapG, sampler_SplatNormalMap_linear_repeat, uvG),_SplatNormalMapIntensityG) * mask.g;
    half3 normalTSB = UnpackNormalScale(SAMPLE_TEXTURE2D(_SplatNormalMapB, sampler_SplatNormalMap_linear_repeat, uvB),_SplatNormalMapIntensityB) * mask.b;
    half3 normalTSA = UnpackNormalScale(SAMPLE_TEXTURE2D(_SplatNormalMapA, sampler_SplatNormalMap_linear_repeat, uvA),_SplatNormalMapIntensityA) * mask.a;
    surfaceData.normalTS = lerp(surfaceData.normalTS, (normalTSR + normalTSG + normalTSB + normalTSA), _SplatMapFeatureOnOff);
#endif
}
//==========================================================================================================================================================

// Used in Standard (Physically Based) shader
void LitPassFragment(
    Varyings input
    , out half4 outColor : SV_Target0
#ifdef _WRITE_RENDERING_LAYERS
    , out float4 outRenderingLayers : SV_Target1
#endif
)
{
    UNITY_SETUP_INSTANCE_ID(input);
    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

#if defined(_PARALLAXMAP)
#if defined(REQUIRES_TANGENT_SPACE_VIEW_DIR_INTERPOLATOR)
    half3 viewDirTS = input.viewDirTS;
#else
    half3 viewDirWS = GetWorldSpaceNormalizeViewDir(input.positionWS);
    half3 viewDirTS = GetViewDirectionTangentSpace(input.tangentWS, input.normalWS, viewDirWS);
#endif
    ApplyPerPixelDisplacement(viewDirTS, input.uv);
#endif

    SurfaceData surfaceData;
    InitializeStandardLitSurfaceData(input.uv, surfaceData);

#if UNITY_VERSION >= 202220
#ifdef LOD_FADE_CROSSFADE
    LODFadeCrossFade(input.positionCS);
#endif
#endif

     //[NiloToon] add:
    //==========================================================================================================================================================
    // albedo,normal,smoothness override by splat map
    ApplySplatMapToSurfaceData(surfaceData, input);

    ApplyCustomUserLogicToSurfaceData(surfaceData, input);
    
    // global albedo override
    surfaceData.albedo.rgb = lerp(surfaceData.albedo.rgb, _NiloToonGlobalEnviAlbedoOverrideColor.rgb, _NiloToonGlobalEnviAlbedoOverrideColor.a);    
    //==========================================================================================================================================================
    
    InputData inputData;
    InitializeInputData(input, surfaceData.normalTS, inputData);

#if UNITY_VERSION >= 60000000
    SETUP_DEBUG_TEXTURE_DATA(inputData, UNDO_TRANSFORM_TEX(input.uv, _BaseMap));
#else
    SETUP_DEBUG_TEXTURE_DATA(inputData, input.uv, _BaseMap);
#endif

#if defined(_DBUFFER)
    ApplyDecalToSurfaceData(input.positionCS, surfaceData, inputData);
#endif

#if UNITY_VERSION >= 60000000
    InitializeBakedGIData(input, inputData);
#endif
    
    //[NiloToon] add:
    //==========================================================================================================================================================
    // debug on off
    if(_NiloToonGlobalEnviMinimumShader)
    {
        Light mainLight = GetMainLight();
        outColor = half4(saturate(dot(mainLight.direction, input.normalWS)) * mainLight.color * surfaceData.albedo,1);
        return;
    }

    // GI edit and override
    inputData.bakedGI = inputData.bakedGI * _NiloToonGlobalEnviGITintColor + _NiloToonGlobalEnviGIAddColor;
    inputData.bakedGI = lerp(inputData.bakedGI, _NiloToonGlobalEnviGIOverride.rgb, _NiloToonGlobalEnviGIOverride.a);
    //==========================================================================================================================================================

    half4 color = UniversalFragmentPBR(inputData, surfaceData);

    //[NiloToon] add:
    //==========================================================================================================================================================
    // copy from URP10.4's Lighting.hlsl->UniversalFragmentPBR()
    // To ensure backward compatibility we have to avoid using shadowMask input, as it is not present in older shaders
#if defined(SHADOWS_SHADOWMASK) && defined(LIGHTMAP_ON)
    half4 shadowMask = inputData.shadowMask;
#elif !defined (LIGHTMAP_ON)
    half4 shadowMask = unity_ProbesOcclusion;
#else
    half4 shadowMask = half4(1, 1, 1, 1);
#endif

    Light mainLight = GetMainLight(inputData.shadowCoord, inputData.positionWS, shadowMask);

    // NiloToon Character Self Shadow
    #if defined(_RECEIVE_NILOTOON_CHAR_SHADOW) && defined(_NILOTOON_RECEIVE_SELF_SHADOW)
    {
        float linearEyeDepth = abs(mul(UNITY_MATRIX_V, float4(input.positionWS, 1)).z);
        half charSelfShadow = SampleNiloToonCharSelfShadow(input.positionWS, inputData.normalWS, linearEyeDepth);
        charSelfShadow = lerp(1, charSelfShadow, _NiloToonCharShadowStrength * _GlobalReceiveNiloToonSelfShadowMap);
        color.rgb *= charSelfShadow;
    }
    #endif

    // shadow border tint color
    float isShadowEdge = 1-abs(mainLight.shadowAttenuation-0.5)*2;
    color.rgb = lerp(color.rgb,color.rgb * _NiloToonGlobalEnviShadowBorderTintColor.rgb, isShadowEdge * _NiloToonGlobalEnviShadowBorderTintColor.a);

    // global surface color result override
    color.rgb = lerp(color.rgb,_NiloToonGlobalEnviSurfaceColorResultOverrideColor.rgb, _NiloToonGlobalEnviSurfaceColorResultOverrideColor.a);

    float2 SV_POSITIONxy = input.positionCS.xy;
    
    // screen space outline
#if _NILOTOON_GLOBAL_ENABLE_SCREENSPACE_OUTLINE || _NILOTOON_GLOBAL_ENABLE_SCREENSPACE_OUTLINE_V2
    // we receive screen space outline only when material's SurfaceType is Opaque. 
    // (_Surface == 0 when SurfaceType is Opaque)
    // (_Surface == 1 when SurfaceType is Transparent)
    // *see BaseShaderGUI.cs in URP package
    if(_Surface == 0) 
    {
        #if _NILOTOON_GLOBAL_ENABLE_SCREENSPACE_OUTLINE
        {
            float finalOutlineWidth = _ScreenSpaceOutlineWidth * _GlobalScreenSpaceOutlineWidthMultiplierForEnvi;
            float finalNormalsSensitivity = max(0,1 + _GlobalScreenSpaceOutlineNormalsSensitivityOffsetForEnvi); // max(0,x) to prevent negative sensitivity
            float finalDepthSensitivity = max(0,1 + _GlobalScreenSpaceOutlineDepthSensitivityOffsetForEnvi); // max(0,x) to prevent negative
            float selfLinearDepth = abs(mul(UNITY_MATRIX_V,float4(input.positionWS,1)).z);

            // reduce finalDepthSensitivity according to depth

            finalDepthSensitivity *= 0.35; // make GUI's default value is 1

            float isScreenSpaceOutlineArea = IsScreenSpaceOutline(
                SV_POSITIONxy, 
                finalOutlineWidth, 
                finalDepthSensitivity, 
                finalNormalsSensitivity, 
                selfLinearDepth, 
                _GlobalScreenSpaceOutlineDepthSensitivityDistanceFadeoutStrengthForEnvi, 
                _CurrentCameraFOV,
                inputData.viewDirectionWS);

            isScreenSpaceOutlineArea *= _GlobalScreenSpaceOutlineIntensityForEnvi * _ScreenSpaceOutlineIntensity;
            color.rgb = lerp(color.rgb, color.rgb * _GlobalScreenSpaceOutlineTintColorForEnvi * _ScreenSpaceOutlineColor.rgb, isScreenSpaceOutlineArea);
        }
        #endif

        //---------------------------------------------------------------

        #if _NILOTOON_GLOBAL_ENABLE_SCREENSPACE_OUTLINE_V2
        {
            // TODO: receive from renderer feature V2
            float width = _GlobalScreenSpaceOutlineV2WidthMultiplierForEnvi;
            float GeometryEdgeThreshold = _GlobalScreenSpaceOutlineV2GeometryEdgeThresholdForEnvi;
            float NormalAngleCosThetaThresholdMin = _GlobalScreenSpaceOutlineV2NormalAngleCosThetaThresholdForEnvi;
            float NormalAngleCosThetaThresholdMax = cos(DegToRad(180));
            bool DrawGeometryEdge = _GlobalScreenSpaceOutlineV2EnableGeometryEdgeForEnvi;
            bool DrawNormalAngleEdge = _GlobalScreenSpaceOutlineV2EnableNormalAngleEdgeForEnvi;
            bool DrawMaterialIDBoundary = false; // not supported for envi
            bool DrawCustomIDBoundary = false; // not supported for envi
            bool DrawWireframe = false;

            float isScreenSpaceOutlineArea = IsScreenSpaceOutlineV2(
                SV_POSITIONxy, 
                width, 
                GeometryEdgeThreshold, 
                NormalAngleCosThetaThresholdMin, 
                NormalAngleCosThetaThresholdMax,
                DrawGeometryEdge,
                DrawNormalAngleEdge,
                DrawMaterialIDBoundary, 
                DrawCustomIDBoundary,
                DrawWireframe,
                input.positionWS);

            color.rgb *= 1-isScreenSpaceOutlineArea * _GlobalScreenSpaceOutlineV2IntensityForEnvi;
        }
        #endif
    }
#endif

    ApplyCustomUserLogicBeforeFog(color, surfaceData, inputData);
    //==========================================================================================================================================================

    color.rgb = MixFog(color.rgb, inputData.fogCoord);

    //[NiloToon] add:
    //==========================================================================================================================================================
    ApplyCustomUserLogicAfterFog(color, surfaceData, inputData);
    //==========================================================================================================================================================
    
#if UNITY_VERSION >= 202220
    color.a = OutputAlpha(color.a, IsSurfaceTypeTransparent(_Surface));
#else
    color.a = OutputAlpha(color.a, _Surface);
#endif

    outColor = color;

#ifdef _WRITE_RENDERING_LAYERS
    uint renderingLayers = GetMeshRenderingLayer();
    outRenderingLayers = float4(EncodeMeshRenderingLayer(renderingLayers), 0, 0, 0);
#endif
}