[Best Tool Asset Store Award] Amplify Shader Editor - Node-based Shader Creation Tool

make certain you your baseColor uses the property _MainTex

Hello there ! Working on Unity 2020.2.1 and 2022.2.5. I have long compilation time (1 hour) for specific shaders. They are based on a “uber” method : I create an amplify function that is a uber for the logic of the shader, and I drop the function node in several shaders. So the main logic is easy to be maintained among the shaders (these shaders have minor changes between them). The uber shader function use itself other functions (functions from amplify but also custom functions).
Do you know why the shaders using the uber shader function take so much time to be compiled (i’m speaking compilation time in editor, not when building) ? Does it come from nesting shader functions ? Is it linked to the usage of static switches ?
I have already tried to delete the library folder to compile on a clean state for the shader, but it change nothing.
Thank you for your help

It’s likely the use of too many static switches
for faster compile time you would be better to use other type of switch when possible, such as local no keywork toggles.

I’ve done that. It no longer works

is there a shader graphs “random range”
equivalent in amplify?

yes it’s a function called Random Range in amplify.

can you reach out to me in discord or email with the shader you’re having trouble with?

Okay, thank you for your reply :slight_smile:

Hi,
I want to import shaders from AssetStore asset,
mainly the combination of toon shader and special effect shader.
Where should I start please?

see
https://discussions.unity.com/t/632467 page-25#post-8948187

Do we have a tutorial on how to import a custom shader into amplify shader editor?

I recommend first start off with Amplify Shader Editor Beginner Tutorial Series
they are a bit older but still can give you the basics.
https://www.youtube.com/playlist?list=PL83m62O3BixCFobu0fRS4W9xTittd3rl8

Amplify also has a very large active community in discord that may be helpful as you learn more.

1 Like

BUG report!
every time i reopen ase canvas ,the property ref of ztest/zwrite will be lossed,and then if I press complie,every thing will be pink. every thing will loss include shader name,
really simple shader here

// Made with Amplify Shader Editor v1.9.1.5
// Available at the Unity Asset Store - http://u3d.as/y3X
Shader "Sh_Main"
{
    Properties
    {
        [HideInInspector] _AlphaCutoff("Alpha Cutoff ", Range(0, 1)) = 0.5
        [HideInInspector] _EmissionColor("Emission Color", Color) = (1,1,1,1)
        [ASEBegin][Enum(UnityEngine.Rendering.CompareFunction)]_ZTestMode("ZTestMode", Int) = 4
        [Toggle]_ZWriteMode("ZWriteMode", Float) = 1
        _MainTex("MainTex", 2D) = "white" {}
        _AlphaClip("AlphaClip", Range( 0 , 1)) = 0.5
        _ShadowAlphaClip("ShadowAlphaClip", Range( 0 , 1)) = 0.5
        [ASEEnd]_StencilValue("StencilValue", Float) = 0
        [HideInInspector] _texcoord( "", 2D ) = "white" {}


        //_TransmissionShadow( "Transmission Shadow", Range( 0, 1 ) ) = 0.5
        //_TransStrength( "Trans Strength", Range( 0, 50 ) ) = 1
        //_TransNormal( "Trans Normal Distortion", Range( 0, 1 ) ) = 0.5
        //_TransScattering( "Trans Scattering", Range( 1, 50 ) ) = 2
        //_TransDirect( "Trans Direct", Range( 0, 1 ) ) = 0.9
        //_TransAmbient( "Trans Ambient", Range( 0, 1 ) ) = 0.1
        //_TransShadow( "Trans Shadow", Range( 0, 1 ) ) = 0.5
        //_TessPhongStrength( "Tess Phong Strength", Range( 0, 1 ) ) = 0.5
        //_TessValue( "Tess Max Tessellation", Range( 1, 32 ) ) = 16
        //_TessMin( "Tess Min Distance", Float ) = 10
        //_TessMax( "Tess Max Distance", Float ) = 25
        //_TessEdgeLength ( "Tess Edge length", Range( 2, 50 ) ) = 16
        //_TessMaxDisp( "Tess Max Displacement", Float ) = 25

        [HideInInspector][ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0
        [HideInInspector][ToggleOff] _EnvironmentReflections("Environment Reflections", Float) = 1.0
        [HideInInspector][ToggleOff] _ReceiveShadows("Receive Shadows", Float) = 1.0

        [HideInInspector] _QueueOffset("_QueueOffset", Float) = 0
        [HideInInspector] _QueueControl("_QueueControl", Float) = -1

        [HideInInspector][NoScaleOffset] unity_Lightmaps("unity_Lightmaps", 2DArray) = "" {}
        [HideInInspector][NoScaleOffset] unity_LightmapsInd("unity_LightmapsInd", 2DArray) = "" {}
        [HideInInspector][NoScaleOffset] unity_ShadowMasks("unity_ShadowMasks", 2DArray) = "" {}
    }

    SubShader
    {
        LOD 0

       

        Tags { "RenderPipeline"="UniversalPipeline" "RenderType"="Opaque" "Queue"="Geometry" "UniversalMaterialType"="Lit" }

        Cull Back
        ZWrite On
        ZTest LEqual
        Offset 0 , 0
        AlphaToMask Off

       

        HLSLINCLUDE
        #pragma target 3.5
        #pragma prefer_hlslcc gles
        // ensure rendering platforms toggle list is visible

        #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
        #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Filtering.hlsl"

        #ifndef ASE_TESS_FUNCS
        #define ASE_TESS_FUNCS
        float4 FixedTess( float tessValue )
        {
            return tessValue;
        }

        float CalcDistanceTessFactor (float4 vertex, float minDist, float maxDist, float tess, float4x4 o2w, float3 cameraPos )
        {
            float3 wpos = mul(o2w,vertex).xyz;
            float dist = distance (wpos, cameraPos);
            float f = clamp(1.0 - (dist - minDist) / (maxDist - minDist), 0.01, 1.0) * tess;
            return f;
        }

        float4 CalcTriEdgeTessFactors (float3 triVertexFactors)
        {
            float4 tess;
            tess.x = 0.5 * (triVertexFactors.y + triVertexFactors.z);
            tess.y = 0.5 * (triVertexFactors.x + triVertexFactors.z);
            tess.z = 0.5 * (triVertexFactors.x + triVertexFactors.y);
            tess.w = (triVertexFactors.x + triVertexFactors.y + triVertexFactors.z) / 3.0f;
            return tess;
        }

        float CalcEdgeTessFactor (float3 wpos0, float3 wpos1, float edgeLen, float3 cameraPos, float4 scParams )
        {
            float dist = distance (0.5 * (wpos0+wpos1), cameraPos);
            float len = distance(wpos0, wpos1);
            float f = max(len * scParams.y / (edgeLen * dist), 1.0);
            return f;
        }

        float DistanceFromPlane (float3 pos, float4 plane)
        {
            float d = dot (float4(pos,1.0f), plane);
            return d;
        }

        bool WorldViewFrustumCull (float3 wpos0, float3 wpos1, float3 wpos2, float cullEps, float4 planes[6] )
        {
            float4 planeTest;
            planeTest.x = (( DistanceFromPlane(wpos0, planes[0]) > -cullEps) ? 1.0f : 0.0f ) +
                            (( DistanceFromPlane(wpos1, planes[0]) > -cullEps) ? 1.0f : 0.0f ) +
                            (( DistanceFromPlane(wpos2, planes[0]) > -cullEps) ? 1.0f : 0.0f );
            planeTest.y = (( DistanceFromPlane(wpos0, planes[1]) > -cullEps) ? 1.0f : 0.0f ) +
                            (( DistanceFromPlane(wpos1, planes[1]) > -cullEps) ? 1.0f : 0.0f ) +
                            (( DistanceFromPlane(wpos2, planes[1]) > -cullEps) ? 1.0f : 0.0f );
            planeTest.z = (( DistanceFromPlane(wpos0, planes[2]) > -cullEps) ? 1.0f : 0.0f ) +
                            (( DistanceFromPlane(wpos1, planes[2]) > -cullEps) ? 1.0f : 0.0f ) +
                            (( DistanceFromPlane(wpos2, planes[2]) > -cullEps) ? 1.0f : 0.0f );
            planeTest.w = (( DistanceFromPlane(wpos0, planes[3]) > -cullEps) ? 1.0f : 0.0f ) +
                            (( DistanceFromPlane(wpos1, planes[3]) > -cullEps) ? 1.0f : 0.0f ) +
                            (( DistanceFromPlane(wpos2, planes[3]) > -cullEps) ? 1.0f : 0.0f );
            return !all (planeTest);
        }

        float4 DistanceBasedTess( float4 v0, float4 v1, float4 v2, float tess, float minDist, float maxDist, float4x4 o2w, float3 cameraPos )
        {
            float3 f;
            f.x = CalcDistanceTessFactor (v0,minDist,maxDist,tess,o2w,cameraPos);
            f.y = CalcDistanceTessFactor (v1,minDist,maxDist,tess,o2w,cameraPos);
            f.z = CalcDistanceTessFactor (v2,minDist,maxDist,tess,o2w,cameraPos);

            return CalcTriEdgeTessFactors (f);
        }

        float4 EdgeLengthBasedTess( float4 v0, float4 v1, float4 v2, float edgeLength, float4x4 o2w, float3 cameraPos, float4 scParams )
        {
            float3 pos0 = mul(o2w,v0).xyz;
            float3 pos1 = mul(o2w,v1).xyz;
            float3 pos2 = mul(o2w,v2).xyz;
            float4 tess;
            tess.x = CalcEdgeTessFactor (pos1, pos2, edgeLength, cameraPos, scParams);
            tess.y = CalcEdgeTessFactor (pos2, pos0, edgeLength, cameraPos, scParams);
            tess.z = CalcEdgeTessFactor (pos0, pos1, edgeLength, cameraPos, scParams);
            tess.w = (tess.x + tess.y + tess.z) / 3.0f;
            return tess;
        }

        float4 EdgeLengthBasedTessCull( float4 v0, float4 v1, float4 v2, float edgeLength, float maxDisplacement, float4x4 o2w, float3 cameraPos, float4 scParams, float4 planes[6] )
        {
            float3 pos0 = mul(o2w,v0).xyz;
            float3 pos1 = mul(o2w,v1).xyz;
            float3 pos2 = mul(o2w,v2).xyz;
            float4 tess;

            if (WorldViewFrustumCull(pos0, pos1, pos2, maxDisplacement, planes))
            {
                tess = 0.0f;
            }
            else
            {
                tess.x = CalcEdgeTessFactor (pos1, pos2, edgeLength, cameraPos, scParams);
                tess.y = CalcEdgeTessFactor (pos2, pos0, edgeLength, cameraPos, scParams);
                tess.z = CalcEdgeTessFactor (pos0, pos1, edgeLength, cameraPos, scParams);
                tess.w = (tess.x + tess.y + tess.z) / 3.0f;
            }
            return tess;
        }
        #endif //ASE_TESS_FUNCS
        ENDHLSL

       
        Pass
        {
           
            Name "Forward"
            Tags { "LightMode"="UniversalForward" }

            Blend One Zero, One Zero
            ZWrite [_ZWriteMode]
            ZTest [_ZTestMode]
            Offset 0 , 0
            ColorMask RGBA

            Stencil
            {
                Ref [_StencilValue]
                Comp Always
                Pass Replace
            }

            HLSLPROGRAM

            #define _NORMAL_DROPOFF_TS 1
            #pragma multi_compile_instancing
            #pragma instancing_options renderinglayer
            #pragma multi_compile_fragment _ LOD_FADE_CROSSFADE
            #pragma multi_compile_fog
            #define ASE_FOG 1
            #define _ALPHATEST_SHADOW_ON 1
            #define _ALPHATEST_ON 1
            #define ASE_SRP_VERSION 120107


            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
            #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
            #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
            #pragma multi_compile_fragment _ _REFLECTION_PROBE_BLENDING
            #pragma multi_compile_fragment _ _REFLECTION_PROBE_BOX_PROJECTION
            #pragma multi_compile_fragment _ _SHADOWS_SOFT
            #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION
            #pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3
            #pragma multi_compile_fragment _ _LIGHT_LAYERS
            #pragma multi_compile_fragment _ _LIGHT_COOKIES
            #pragma multi_compile _ _CLUSTERED_RENDERING
            #pragma shader_feature_local _RECEIVE_SHADOWS_OFF
            #pragma shader_feature_local_fragment _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local_fragment _ENVIRONMENTREFLECTIONS_OFF

            #pragma multi_compile _ LIGHTMAP_SHADOW_MIXING
            #pragma multi_compile _ SHADOWS_SHADOWMASK
            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
            #pragma multi_compile _ LIGHTMAP_ON
            #pragma multi_compile _ DYNAMICLIGHTMAP_ON
            #pragma multi_compile_fragment _ DEBUG_DISPLAY

            #pragma vertex vert
            #pragma fragment frag

            #define SHADERPASS SHADERPASS_FORWARD

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DBuffer.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl"

            #if defined(UNITY_INSTANCING_ENABLED) && defined(_TERRAIN_INSTANCED_PERPIXEL_NORMAL)
                #define ENABLE_TERRAIN_PERPIXEL_NORMAL
            #endif

           

            struct VertexInput
            {
                float4 vertex : POSITION;
                float3 ase_normal : NORMAL;
                float4 ase_tangent : TANGENT;
                float4 texcoord : TEXCOORD0;
                float4 texcoord1 : TEXCOORD1;
                float4 texcoord2 : TEXCOORD2;
               
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct VertexOutput
            {
                float4 clipPos : SV_POSITION;
                float4 lightmapUVOrVertexSH : TEXCOORD0;
                half4 fogFactorAndVertexLight : TEXCOORD1;
                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                    float4 shadowCoord : TEXCOORD2;
                #endif
                float4 tSpace0 : TEXCOORD3;
                float4 tSpace1 : TEXCOORD4;
                float4 tSpace2 : TEXCOORD5;
                #if defined(ASE_NEEDS_FRAG_SCREEN_POSITION)
                    float4 screenPos : TEXCOORD6;
                #endif
                #if defined(DYNAMICLIGHTMAP_ON)
                    float2 dynamicLightmapUV : TEXCOORD7;
                #endif
                float4 ase_texcoord8 : TEXCOORD8;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            CBUFFER_START(UnityPerMaterial)
            float4 _MainTex_ST;
            float _ZWriteMode;
            int _ZTestMode;
            float _StencilValue;
            float _AlphaClip;
            float _ShadowAlphaClip;
            #ifdef ASE_TRANSMISSION
                float _TransmissionShadow;
            #endif
            #ifdef ASE_TRANSLUCENCY
                float _TransStrength;
                float _TransNormal;
                float _TransScattering;
                float _TransDirect;
                float _TransAmbient;
                float _TransShadow;
            #endif
            #ifdef ASE_TESSELLATION
                float _TessPhongStrength;
                float _TessValue;
                float _TessMin;
                float _TessMax;
                float _TessEdgeLength;
                float _TessMaxDisp;
            #endif
            CBUFFER_END

            // Property used by ScenePickingPass
            #ifdef SCENEPICKINGPASS
                float4 _SelectionID;
            #endif

            // Properties used by SceneSelectionPass
            #ifdef SCENESELECTIONPASS
                int _ObjectId;
                int _PassValue;
            #endif

            sampler2D _MainTex;


            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Varyings.hlsl"
            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/PBRForwardPass.hlsl"

            //#ifdef HAVE_VFX_MODIFICATION
            //#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/VisualEffectVertex.hlsl"
            //#endif

           
            VertexOutput VertexFunction( VertexInput v  )
            {
                VertexOutput o = (VertexOutput)0;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

                o.ase_texcoord8.xy = v.texcoord.xy;
               
                //setting value to unused interpolator channels and avoid initialization warnings
                o.ase_texcoord8.zw = 0;

                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    float3 defaultVertexValue = v.vertex.xyz;
                #else
                    float3 defaultVertexValue = float3(0, 0, 0);
                #endif

                float3 vertexValue = defaultVertexValue;

                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    v.vertex.xyz = vertexValue;
                #else
                    v.vertex.xyz += vertexValue;
                #endif
                v.ase_normal = v.ase_normal;

                float3 positionWS = TransformObjectToWorld( v.vertex.xyz );
                float3 positionVS = TransformWorldToView( positionWS );
                float4 positionCS = TransformWorldToHClip( positionWS );

                VertexNormalInputs normalInput = GetVertexNormalInputs( v.ase_normal, v.ase_tangent );

                o.tSpace0 = float4( normalInput.normalWS, positionWS.x);
                o.tSpace1 = float4( normalInput.tangentWS, positionWS.y);
                o.tSpace2 = float4( normalInput.bitangentWS, positionWS.z);

                #if defined(LIGHTMAP_ON)
                    OUTPUT_LIGHTMAP_UV( v.texcoord1, unity_LightmapST, o.lightmapUVOrVertexSH.xy );
                #endif

                #if !defined(LIGHTMAP_ON)
                    OUTPUT_SH( normalInput.normalWS.xyz, o.lightmapUVOrVertexSH.xyz );
                #endif

                #if defined(DYNAMICLIGHTMAP_ON)
                    o.dynamicLightmapUV.xy = v.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
                #endif

                #if defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)
                    o.lightmapUVOrVertexSH.zw = v.texcoord;
                    o.lightmapUVOrVertexSH.xy = v.texcoord * unity_LightmapST.xy + unity_LightmapST.zw;
                #endif

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

                #ifdef ASE_FOG
                    half fogFactor = ComputeFogFactor( positionCS.z );
                #else
                    half fogFactor = 0;
                #endif

                o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);

                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                    VertexPositionInputs vertexInput = (VertexPositionInputs)0;
                    vertexInput.positionWS = positionWS;
                    vertexInput.positionCS = positionCS;
                    o.shadowCoord = GetShadowCoord( vertexInput );
                #endif

                o.clipPos = positionCS;

                #if defined(ASE_NEEDS_FRAG_SCREEN_POSITION)
                    o.screenPos = ComputeScreenPos(positionCS);
                #endif

                return o;
            }

            #if defined(ASE_TESSELLATION)
            struct VertexControl
            {
                float4 vertex : INTERNALTESSPOS;
                float3 ase_normal : NORMAL;
                float4 ase_tangent : TANGENT;
                float4 texcoord : TEXCOORD0;
                float4 texcoord1 : TEXCOORD1;
                float4 texcoord2 : TEXCOORD2;
               
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct TessellationFactors
            {
                float edge[3] : SV_TessFactor;
                float inside : SV_InsideTessFactor;
            };

            VertexControl vert ( VertexInput v )
            {
                VertexControl o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                o.vertex = v.vertex;
                o.ase_normal = v.ase_normal;
                o.ase_tangent = v.ase_tangent;
                o.texcoord = v.texcoord;
                o.texcoord1 = v.texcoord1;
                o.texcoord2 = v.texcoord2;
               
                return o;
            }

            TessellationFactors TessellationFunction (InputPatch<VertexControl,3> v)
            {
                TessellationFactors o;
                float4 tf = 1;
                float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax;
                float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp;
                #if defined(ASE_FIXED_TESSELLATION)
                tf = FixedTess( tessValue );
                #elif defined(ASE_DISTANCE_TESSELLATION)
                tf = DistanceBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos );
                #elif defined(ASE_LENGTH_TESSELLATION)
                tf = EdgeLengthBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams );
                #elif defined(ASE_LENGTH_CULL_TESSELLATION)
                tf = EdgeLengthBasedTessCull(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes );
                #endif
                o.edge[0] = tf.x; o.edge[1] = tf.y; o.edge[2] = tf.z; o.inside = tf.w;
                return o;
            }

            [domain("tri")]
            [partitioning("fractional_odd")]
            [outputtopology("triangle_cw")]
            [patchconstantfunc("TessellationFunction")]
            [outputcontrolpoints(3)]
            VertexControl HullFunction(InputPatch<VertexControl, 3> patch, uint id : SV_OutputControlPointID)
            {
                return patch[id];
            }

            [domain("tri")]
            VertexOutput DomainFunction(TessellationFactors factors, OutputPatch<VertexControl, 3> patch, float3 bary : SV_DomainLocation)
            {
                VertexInput o = (VertexInput) 0;
                o.vertex = patch[0].vertex * bary.x + patch[1].vertex * bary.y + patch[2].vertex * bary.z;
                o.ase_normal = patch[0].ase_normal * bary.x + patch[1].ase_normal * bary.y + patch[2].ase_normal * bary.z;
                o.ase_tangent = patch[0].ase_tangent * bary.x + patch[1].ase_tangent * bary.y + patch[2].ase_tangent * bary.z;
                o.texcoord = patch[0].texcoord * bary.x + patch[1].texcoord * bary.y + patch[2].texcoord * bary.z;
                o.texcoord1 = patch[0].texcoord1 * bary.x + patch[1].texcoord1 * bary.y + patch[2].texcoord1 * bary.z;
                o.texcoord2 = patch[0].texcoord2 * bary.x + patch[1].texcoord2 * bary.y + patch[2].texcoord2 * bary.z;
               
                #if defined(ASE_PHONG_TESSELLATION)
                float3 pp[3];
                for (int i = 0; i < 3; ++i)
                    pp[i] = o.vertex.xyz - patch[i].ase_normal * (dot(o.vertex.xyz, patch[i].ase_normal) - dot(patch[i].vertex.xyz, patch[i].ase_normal));
                float phongStrength = _TessPhongStrength;
                o.vertex.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * o.vertex.xyz;
                #endif
                UNITY_TRANSFER_INSTANCE_ID(patch[0], o);
                return VertexFunction(o);
            }
            #else
            VertexOutput vert ( VertexInput v )
            {
                return VertexFunction( v );
            }
            #endif

            #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE)
                #define ASE_SV_DEPTH SV_DepthLessEqual
            #else
                #define ASE_SV_DEPTH SV_Depth
            #endif

            half4 frag ( VertexOutput IN
                        #ifdef ASE_DEPTH_WRITE_ON
                        ,out float outputDepth : ASE_SV_DEPTH
                        #endif
                         ) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(IN);

                #ifdef LOD_FADE_CROSSFADE
                    LODDitheringTransition( IN.clipPos.xyz, unity_LODFade.x );
                #endif

                #if defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)
                    float2 sampleCoords = (IN.lightmapUVOrVertexSH.zw / _TerrainHeightmapRecipSize.zw + 0.5f) * _TerrainHeightmapRecipSize.xy;
                    float3 WorldNormal = TransformObjectToWorldNormal(normalize(SAMPLE_TEXTURE2D(_TerrainNormalmapTexture, sampler_TerrainNormalmapTexture, sampleCoords).rgb * 2 - 1));
                    float3 WorldTangent = -cross(GetObjectToWorldMatrix()._13_23_33, WorldNormal);
                    float3 WorldBiTangent = cross(WorldNormal, -WorldTangent);
                #else
                    float3 WorldNormal = normalize( IN.tSpace0.xyz );
                    float3 WorldTangent = IN.tSpace1.xyz;
                    float3 WorldBiTangent = IN.tSpace2.xyz;
                #endif

                float3 WorldPosition = float3(IN.tSpace0.w,IN.tSpace1.w,IN.tSpace2.w);
                float3 WorldViewDirection = _WorldSpaceCameraPos.xyz  - WorldPosition;
                float4 ShadowCoords = float4( 0, 0, 0, 0 );

                #if defined(ASE_NEEDS_FRAG_SCREEN_POSITION)
                    float4 ScreenPos = IN.screenPos;
                #endif

                float2 NormalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(IN.clipPos);

                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                    ShadowCoords = IN.shadowCoord;
                #elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
                    ShadowCoords = TransformWorldToShadowCoord( WorldPosition );
                #endif

                WorldViewDirection = SafeNormalize( WorldViewDirection );

                float2 uv_MainTex = IN.ase_texcoord8.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                float4 tex2DNode13 = tex2D( _MainTex, uv_MainTex );
               

                float3 BaseColor = tex2DNode13.rgb;
                float3 Normal = float3(0, 0, 1);
                float3 Emission = 0;
                float3 Specular = 0.5;
                float Metallic = 0.0;
                float Smoothness = 0.0;
                float Occlusion = 1.0;
                float Alpha = ( tex2DNode13.a * 1.0 );
                float AlphaClipThreshold = _AlphaClip;
                float AlphaClipThresholdShadow = _ShadowAlphaClip;
                float3 BakedGI = 0;
                float3 RefractionColor = 1;
                float RefractionIndex = 1;
                float3 Transmission = 1;
                float3 Translucency = 1;

                #ifdef ASE_DEPTH_WRITE_ON
                    float DepthValue = 0;
                #endif

                #ifdef _CLEARCOAT
                    float CoatMask = 0;
                    float CoatSmoothness = 0;
                #endif

                #ifdef _ALPHATEST_ON
                    clip(Alpha - AlphaClipThreshold);
                #endif

                InputData inputData = (InputData)0;
                inputData.positionWS = WorldPosition;
                inputData.viewDirectionWS = WorldViewDirection;

                #ifdef _NORMALMAP
                        #if _NORMAL_DROPOFF_TS
                            inputData.normalWS = TransformTangentToWorld(Normal, half3x3(WorldTangent, WorldBiTangent, WorldNormal));
                        #elif _NORMAL_DROPOFF_OS
                            inputData.normalWS = TransformObjectToWorldNormal(Normal);
                        #elif _NORMAL_DROPOFF_WS
                            inputData.normalWS = Normal;
                        #endif
                    inputData.normalWS = NormalizeNormalPerPixel(inputData.normalWS);
                #else
                    inputData.normalWS = WorldNormal;
                #endif

                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                    inputData.shadowCoord = ShadowCoords;
                #elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
                    inputData.shadowCoord = TransformWorldToShadowCoord(inputData.positionWS);
                #else
                    inputData.shadowCoord = float4(0, 0, 0, 0);
                #endif

                #ifdef ASE_FOG
                    inputData.fogCoord = IN.fogFactorAndVertexLight.x;
                #endif
                    inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;

                #if defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)
                    float3 SH = SampleSH(inputData.normalWS.xyz);
                #else
                    float3 SH = IN.lightmapUVOrVertexSH.xyz;
                #endif

                #if defined(DYNAMICLIGHTMAP_ON)
                    inputData.bakedGI = SAMPLE_GI(IN.lightmapUVOrVertexSH.xy, IN.dynamicLightmapUV.xy, SH, inputData.normalWS);
                #else
                    inputData.bakedGI = SAMPLE_GI(IN.lightmapUVOrVertexSH.xy, SH, inputData.normalWS);
                #endif

                #ifdef ASE_BAKEDGI
                    inputData.bakedGI = BakedGI;
                #endif

                inputData.normalizedScreenSpaceUV = NormalizedScreenSpaceUV;
                inputData.shadowMask = SAMPLE_SHADOWMASK(IN.lightmapUVOrVertexSH.xy);

                #if defined(DEBUG_DISPLAY)
                    #if defined(DYNAMICLIGHTMAP_ON)
                        inputData.dynamicLightmapUV = IN.dynamicLightmapUV.xy;
                    #endif
                    #if defined(LIGHTMAP_ON)
                        inputData.staticLightmapUV = IN.lightmapUVOrVertexSH.xy;
                    #else
                        inputData.vertexSH = SH;
                    #endif
                #endif

                SurfaceData surfaceData;
                surfaceData.albedo              = BaseColor;
                surfaceData.metallic            = saturate(Metallic);
                surfaceData.specular            = Specular;
                surfaceData.smoothness          = saturate(Smoothness),
                surfaceData.occlusion           = Occlusion,
                surfaceData.emission            = Emission,
                surfaceData.alpha               = saturate(Alpha);
                surfaceData.normalTS            = Normal;
                surfaceData.clearCoatMask       = 0;
                surfaceData.clearCoatSmoothness = 1;

                #ifdef _CLEARCOAT
                    surfaceData.clearCoatMask       = saturate(CoatMask);
                    surfaceData.clearCoatSmoothness = saturate(CoatSmoothness);
                #endif

                #ifdef _DBUFFER
                    ApplyDecalToSurfaceData(IN.clipPos, surfaceData, inputData);
                #endif

                half4 color = UniversalFragmentPBR( inputData, surfaceData);

                #ifdef ASE_TRANSMISSION
                {
                    float shadow = _TransmissionShadow;

                    Light mainLight = GetMainLight( inputData.shadowCoord );
                    float3 mainAtten = mainLight.color * mainLight.distanceAttenuation;
                    mainAtten = lerp( mainAtten, mainAtten * mainLight.shadowAttenuation, shadow );
                    half3 mainTransmission = max(0 , -dot(inputData.normalWS, mainLight.direction)) * mainAtten * Transmission;
                    color.rgb += BaseColor * mainTransmission;

                    #ifdef _ADDITIONAL_LIGHTS
                        int transPixelLightCount = GetAdditionalLightsCount();
                        for (int i = 0; i < transPixelLightCount; ++i)
                        {
                            Light light = GetAdditionalLight(i, inputData.positionWS);
                            float3 atten = light.color * light.distanceAttenuation;
                            atten = lerp( atten, atten * light.shadowAttenuation, shadow );

                            half3 transmission = max(0 , -dot(inputData.normalWS, light.direction)) * atten * Transmission;
                            color.rgb += BaseColor * transmission;
                        }
                    #endif
                }
                #endif

                #ifdef ASE_TRANSLUCENCY
                {
                    float shadow = _TransShadow;
                    float normal = _TransNormal;
                    float scattering = _TransScattering;
                    float direct = _TransDirect;
                    float ambient = _TransAmbient;
                    float strength = _TransStrength;

                    Light mainLight = GetMainLight( inputData.shadowCoord );
                    float3 mainAtten = mainLight.color * mainLight.distanceAttenuation;
                    mainAtten = lerp( mainAtten, mainAtten * mainLight.shadowAttenuation, shadow );

                    half3 mainLightDir = mainLight.direction + inputData.normalWS * normal;
                    half mainVdotL = pow( saturate( dot( inputData.viewDirectionWS, -mainLightDir ) ), scattering );
                    half3 mainTranslucency = mainAtten * ( mainVdotL * direct + inputData.bakedGI * ambient ) * Translucency;
                    color.rgb += BaseColor * mainTranslucency * strength;

                    #ifdef _ADDITIONAL_LIGHTS
                        int transPixelLightCount = GetAdditionalLightsCount();
                        for (int i = 0; i < transPixelLightCount; ++i)
                        {
                            Light light = GetAdditionalLight(i, inputData.positionWS);
                            float3 atten = light.color * light.distanceAttenuation;
                            atten = lerp( atten, atten * light.shadowAttenuation, shadow );

                            half3 lightDir = light.direction + inputData.normalWS * normal;
                            half VdotL = pow( saturate( dot( inputData.viewDirectionWS, -lightDir ) ), scattering );
                            half3 translucency = atten * ( VdotL * direct + inputData.bakedGI * ambient ) * Translucency;
                            color.rgb += BaseColor * translucency * strength;
                        }
                    #endif
                }
                #endif

                #ifdef ASE_REFRACTION
                    float4 projScreenPos = ScreenPos / ScreenPos.w;
                    float3 refractionOffset = ( RefractionIndex - 1.0 ) * mul( UNITY_MATRIX_V, float4( WorldNormal,0 ) ).xyz * ( 1.0 - dot( WorldNormal, WorldViewDirection ) );
                    projScreenPos.xy += refractionOffset.xy;
                    float3 refraction = SHADERGRAPH_SAMPLE_SCENE_COLOR( projScreenPos.xy ) * RefractionColor;
                    color.rgb = lerp( refraction, color.rgb, color.a );
                    color.a = 1;
                #endif

                #ifdef ASE_FINAL_COLOR_ALPHA_MULTIPLY
                    color.rgb *= color.a;
                #endif

                #ifdef ASE_FOG
                    #ifdef TERRAIN_SPLAT_ADDPASS
                        color.rgb = MixFogColor(color.rgb, half3( 0, 0, 0 ), IN.fogFactorAndVertexLight.x );
                    #else
                        color.rgb = MixFog(color.rgb, IN.fogFactorAndVertexLight.x);
                    #endif
                #endif

                #ifdef ASE_DEPTH_WRITE_ON
                    outputDepth = DepthValue;
                #endif

                return color;
            }

            ENDHLSL
        }

       
        Pass
        {
           
            Name "ShadowCaster"
            Tags { "LightMode"="ShadowCaster" }

            ZWrite On
            ZTest LEqual
            AlphaToMask Off
            ColorMask 0

            HLSLPROGRAM

            #define _NORMAL_DROPOFF_TS 1
            #pragma multi_compile_instancing
            #pragma multi_compile_fragment _ LOD_FADE_CROSSFADE
            #define ASE_FOG 1
            #define _ALPHATEST_SHADOW_ON 1
            #define _ALPHATEST_ON 1
            #define ASE_SRP_VERSION 120107


            #pragma vertex vert
            #pragma fragment frag

            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW

            #define SHADERPASS SHADERPASS_SHADOWCASTER

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl"

           

            struct VertexInput
            {
                float4 vertex : POSITION;
                float3 ase_normal : NORMAL;
                float4 ase_texcoord : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct VertexOutput
            {
                float4 clipPos : SV_POSITION;
                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    float3 worldPos : TEXCOORD0;
                #endif
                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR) && defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    float4 shadowCoord : TEXCOORD1;
                #endif
                float4 ase_texcoord2 : TEXCOORD2;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            CBUFFER_START(UnityPerMaterial)
            float4 _MainTex_ST;
            float _ZWriteMode;
            int _ZTestMode;
            float _StencilValue;
            float _AlphaClip;
            float _ShadowAlphaClip;
            #ifdef ASE_TRANSMISSION
                float _TransmissionShadow;
            #endif
            #ifdef ASE_TRANSLUCENCY
                float _TransStrength;
                float _TransNormal;
                float _TransScattering;
                float _TransDirect;
                float _TransAmbient;
                float _TransShadow;
            #endif
            #ifdef ASE_TESSELLATION
                float _TessPhongStrength;
                float _TessValue;
                float _TessMin;
                float _TessMax;
                float _TessEdgeLength;
                float _TessMaxDisp;
            #endif
            CBUFFER_END

            // Property used by ScenePickingPass
            #ifdef SCENEPICKINGPASS
                float4 _SelectionID;
            #endif

            // Properties used by SceneSelectionPass
            #ifdef SCENESELECTIONPASS
                int _ObjectId;
                int _PassValue;
            #endif

            sampler2D _MainTex;


            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Varyings.hlsl"
            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShadowCasterPass.hlsl"

            //#ifdef HAVE_VFX_MODIFICATION
            //#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/VisualEffectVertex.hlsl"
            //#endif

           
            float3 _LightDirection;
            float3 _LightPosition;

            VertexOutput VertexFunction( VertexInput v )
            {
                VertexOutput o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO( o );

                o.ase_texcoord2.xy = v.ase_texcoord.xy;
               
                //setting value to unused interpolator channels and avoid initialization warnings
                o.ase_texcoord2.zw = 0;

                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    float3 defaultVertexValue = v.vertex.xyz;
                #else
                    float3 defaultVertexValue = float3(0, 0, 0);
                #endif

                float3 vertexValue = defaultVertexValue;
                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    v.vertex.xyz = vertexValue;
                #else
                    v.vertex.xyz += vertexValue;
                #endif

                v.ase_normal = v.ase_normal;

                float3 positionWS = TransformObjectToWorld( v.vertex.xyz );

                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    o.worldPos = positionWS;
                #endif

                float3 normalWS = TransformObjectToWorldDir(v.ase_normal);

                #if _CASTING_PUNCTUAL_LIGHT_SHADOW
                    float3 lightDirectionWS = normalize(_LightPosition - positionWS);
                #else
                    float3 lightDirectionWS = _LightDirection;
                #endif

                float4 clipPos = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, lightDirectionWS));

                #if UNITY_REVERSED_Z
                    clipPos.z = min(clipPos.z, UNITY_NEAR_CLIP_VALUE);
                #else
                    clipPos.z = max(clipPos.z, UNITY_NEAR_CLIP_VALUE);
                #endif

                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR) && defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    VertexPositionInputs vertexInput = (VertexPositionInputs)0;
                    vertexInput.positionWS = positionWS;
                    vertexInput.positionCS = clipPos;
                    o.shadowCoord = GetShadowCoord( vertexInput );
                #endif

                o.clipPos = clipPos;

                return o;
            }

            #if defined(ASE_TESSELLATION)
            struct VertexControl
            {
                float4 vertex : INTERNALTESSPOS;
                float3 ase_normal : NORMAL;
                float4 ase_texcoord : TEXCOORD0;

                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct TessellationFactors
            {
                float edge[3] : SV_TessFactor;
                float inside : SV_InsideTessFactor;
            };

            VertexControl vert ( VertexInput v )
            {
                VertexControl o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                o.vertex = v.vertex;
                o.ase_normal = v.ase_normal;
                o.ase_texcoord = v.ase_texcoord;
                return o;
            }

            TessellationFactors TessellationFunction (InputPatch<VertexControl,3> v)
            {
                TessellationFactors o;
                float4 tf = 1;
                float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax;
                float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp;
                #if defined(ASE_FIXED_TESSELLATION)
                tf = FixedTess( tessValue );
                #elif defined(ASE_DISTANCE_TESSELLATION)
                tf = DistanceBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos );
                #elif defined(ASE_LENGTH_TESSELLATION)
                tf = EdgeLengthBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams );
                #elif defined(ASE_LENGTH_CULL_TESSELLATION)
                tf = EdgeLengthBasedTessCull(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes );
                #endif
                o.edge[0] = tf.x; o.edge[1] = tf.y; o.edge[2] = tf.z; o.inside = tf.w;
                return o;
            }

            [domain("tri")]
            [partitioning("fractional_odd")]
            [outputtopology("triangle_cw")]
            [patchconstantfunc("TessellationFunction")]
            [outputcontrolpoints(3)]
            VertexControl HullFunction(InputPatch<VertexControl, 3> patch, uint id : SV_OutputControlPointID)
            {
                return patch[id];
            }

            [domain("tri")]
            VertexOutput DomainFunction(TessellationFactors factors, OutputPatch<VertexControl, 3> patch, float3 bary : SV_DomainLocation)
            {
                VertexInput o = (VertexInput) 0;
                o.vertex = patch[0].vertex * bary.x + patch[1].vertex * bary.y + patch[2].vertex * bary.z;
                o.ase_normal = patch[0].ase_normal * bary.x + patch[1].ase_normal * bary.y + patch[2].ase_normal * bary.z;
                o.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z;
                #if defined(ASE_PHONG_TESSELLATION)
                float3 pp[3];
                for (int i = 0; i < 3; ++i)
                    pp[i] = o.vertex.xyz - patch[i].ase_normal * (dot(o.vertex.xyz, patch[i].ase_normal) - dot(patch[i].vertex.xyz, patch[i].ase_normal));
                float phongStrength = _TessPhongStrength;
                o.vertex.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * o.vertex.xyz;
                #endif
                UNITY_TRANSFER_INSTANCE_ID(patch[0], o);
                return VertexFunction(o);
            }
            #else
            VertexOutput vert ( VertexInput v )
            {
                return VertexFunction( v );
            }
            #endif

            #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE)
                #define ASE_SV_DEPTH SV_DepthLessEqual
            #else
                #define ASE_SV_DEPTH SV_Depth
            #endif

            half4 frag(    VertexOutput IN
                        #ifdef ASE_DEPTH_WRITE_ON
                        ,out float outputDepth : ASE_SV_DEPTH
                        #endif
                         ) : SV_TARGET
            {
                UNITY_SETUP_INSTANCE_ID( IN );
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX( IN );

                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    float3 WorldPosition = IN.worldPos;
                #endif

                float4 ShadowCoords = float4( 0, 0, 0, 0 );

                #if defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                        ShadowCoords = IN.shadowCoord;
                    #elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
                        ShadowCoords = TransformWorldToShadowCoord( WorldPosition );
                    #endif
                #endif

                float2 uv_MainTex = IN.ase_texcoord2.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                float4 tex2DNode13 = tex2D( _MainTex, uv_MainTex );
               

                float Alpha = ( tex2DNode13.a * 1.0 );
                float AlphaClipThreshold = _AlphaClip;
                float AlphaClipThresholdShadow = _ShadowAlphaClip;

                #ifdef ASE_DEPTH_WRITE_ON
                    float DepthValue = 0;
                #endif

                #ifdef _ALPHATEST_ON
                    #ifdef _ALPHATEST_SHADOW_ON
                        clip(Alpha - AlphaClipThresholdShadow);
                    #else
                        clip(Alpha - AlphaClipThreshold);
                    #endif
                #endif

                #ifdef LOD_FADE_CROSSFADE
                    LODDitheringTransition( IN.clipPos.xyz, unity_LODFade.x );
                #endif

                #ifdef ASE_DEPTH_WRITE_ON
                    outputDepth = DepthValue;
                #endif

                return 0;
            }
            ENDHLSL
        }

       
        Pass
        {
           
            Name "DepthOnly"
            Tags { "LightMode"="DepthOnly" }

            ZWrite On
            ColorMask 0
            AlphaToMask Off

            HLSLPROGRAM

            #define _NORMAL_DROPOFF_TS 1
            #pragma multi_compile_instancing
            #pragma multi_compile_fragment _ LOD_FADE_CROSSFADE
            #define ASE_FOG 1
            #define _ALPHATEST_SHADOW_ON 1
            #define _ALPHATEST_ON 1
            #define ASE_SRP_VERSION 120107


            #pragma vertex vert
            #pragma fragment frag

            #define SHADERPASS SHADERPASS_DEPTHONLY

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl"

           

            struct VertexInput
            {
                float4 vertex : POSITION;
                float3 ase_normal : NORMAL;
                float4 ase_texcoord : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct VertexOutput
            {
                float4 clipPos : SV_POSITION;
                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                float3 worldPos : TEXCOORD0;
                #endif
                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR) && defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                float4 shadowCoord : TEXCOORD1;
                #endif
                float4 ase_texcoord2 : TEXCOORD2;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            CBUFFER_START(UnityPerMaterial)
            float4 _MainTex_ST;
            float _ZWriteMode;
            int _ZTestMode;
            float _StencilValue;
            float _AlphaClip;
            float _ShadowAlphaClip;
            #ifdef ASE_TRANSMISSION
                float _TransmissionShadow;
            #endif
            #ifdef ASE_TRANSLUCENCY
                float _TransStrength;
                float _TransNormal;
                float _TransScattering;
                float _TransDirect;
                float _TransAmbient;
                float _TransShadow;
            #endif
            #ifdef ASE_TESSELLATION
                float _TessPhongStrength;
                float _TessValue;
                float _TessMin;
                float _TessMax;
                float _TessEdgeLength;
                float _TessMaxDisp;
            #endif
            CBUFFER_END

            // Property used by ScenePickingPass
            #ifdef SCENEPICKINGPASS
                float4 _SelectionID;
            #endif

            // Properties used by SceneSelectionPass
            #ifdef SCENESELECTIONPASS
                int _ObjectId;
                int _PassValue;
            #endif

            sampler2D _MainTex;


            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Varyings.hlsl"
            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/DepthOnlyPass.hlsl"

            //#ifdef HAVE_VFX_MODIFICATION
            //#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/VisualEffectVertex.hlsl"
            //#endif

           
            VertexOutput VertexFunction( VertexInput v  )
            {
                VertexOutput o = (VertexOutput)0;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

                o.ase_texcoord2.xy = v.ase_texcoord.xy;
               
                //setting value to unused interpolator channels and avoid initialization warnings
                o.ase_texcoord2.zw = 0;

                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    float3 defaultVertexValue = v.vertex.xyz;
                #else
                    float3 defaultVertexValue = float3(0, 0, 0);
                #endif

                float3 vertexValue = defaultVertexValue;

                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    v.vertex.xyz = vertexValue;
                #else
                    v.vertex.xyz += vertexValue;
                #endif

                v.ase_normal = v.ase_normal;
                float3 positionWS = TransformObjectToWorld( v.vertex.xyz );
                float4 positionCS = TransformWorldToHClip( positionWS );

                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    o.worldPos = positionWS;
                #endif

                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR) && defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    VertexPositionInputs vertexInput = (VertexPositionInputs)0;
                    vertexInput.positionWS = positionWS;
                    vertexInput.positionCS = positionCS;
                    o.shadowCoord = GetShadowCoord( vertexInput );
                #endif

                o.clipPos = positionCS;

                return o;
            }

            #if defined(ASE_TESSELLATION)
            struct VertexControl
            {
                float4 vertex : INTERNALTESSPOS;
                float3 ase_normal : NORMAL;
                float4 ase_texcoord : TEXCOORD0;

                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct TessellationFactors
            {
                float edge[3] : SV_TessFactor;
                float inside : SV_InsideTessFactor;
            };

            VertexControl vert ( VertexInput v )
            {
                VertexControl o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                o.vertex = v.vertex;
                o.ase_normal = v.ase_normal;
                o.ase_texcoord = v.ase_texcoord;
                return o;
            }

            TessellationFactors TessellationFunction (InputPatch<VertexControl,3> v)
            {
                TessellationFactors o;
                float4 tf = 1;
                float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax;
                float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp;
                #if defined(ASE_FIXED_TESSELLATION)
                tf = FixedTess( tessValue );
                #elif defined(ASE_DISTANCE_TESSELLATION)
                tf = DistanceBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos );
                #elif defined(ASE_LENGTH_TESSELLATION)
                tf = EdgeLengthBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams );
                #elif defined(ASE_LENGTH_CULL_TESSELLATION)
                tf = EdgeLengthBasedTessCull(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes );
                #endif
                o.edge[0] = tf.x; o.edge[1] = tf.y; o.edge[2] = tf.z; o.inside = tf.w;
                return o;
            }

            [domain("tri")]
            [partitioning("fractional_odd")]
            [outputtopology("triangle_cw")]
            [patchconstantfunc("TessellationFunction")]
            [outputcontrolpoints(3)]
            VertexControl HullFunction(InputPatch<VertexControl, 3> patch, uint id : SV_OutputControlPointID)
            {
                return patch[id];
            }

            [domain("tri")]
            VertexOutput DomainFunction(TessellationFactors factors, OutputPatch<VertexControl, 3> patch, float3 bary : SV_DomainLocation)
            {
                VertexInput o = (VertexInput) 0;
                o.vertex = patch[0].vertex * bary.x + patch[1].vertex * bary.y + patch[2].vertex * bary.z;
                o.ase_normal = patch[0].ase_normal * bary.x + patch[1].ase_normal * bary.y + patch[2].ase_normal * bary.z;
                o.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z;
                #if defined(ASE_PHONG_TESSELLATION)
                float3 pp[3];
                for (int i = 0; i < 3; ++i)
                    pp[i] = o.vertex.xyz - patch[i].ase_normal * (dot(o.vertex.xyz, patch[i].ase_normal) - dot(patch[i].vertex.xyz, patch[i].ase_normal));
                float phongStrength = _TessPhongStrength;
                o.vertex.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * o.vertex.xyz;
                #endif
                UNITY_TRANSFER_INSTANCE_ID(patch[0], o);
                return VertexFunction(o);
            }
            #else
            VertexOutput vert ( VertexInput v )
            {
                return VertexFunction( v );
            }
            #endif

            #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE)
                #define ASE_SV_DEPTH SV_DepthLessEqual
            #else
                #define ASE_SV_DEPTH SV_Depth
            #endif

            half4 frag(    VertexOutput IN
                        #ifdef ASE_DEPTH_WRITE_ON
                        ,out float outputDepth : ASE_SV_DEPTH
                        #endif
                         ) : SV_TARGET
            {
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX( IN );

                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                float3 WorldPosition = IN.worldPos;
                #endif

                float4 ShadowCoords = float4( 0, 0, 0, 0 );

                #if defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                        ShadowCoords = IN.shadowCoord;
                    #elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
                        ShadowCoords = TransformWorldToShadowCoord( WorldPosition );
                    #endif
                #endif

                float2 uv_MainTex = IN.ase_texcoord2.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                float4 tex2DNode13 = tex2D( _MainTex, uv_MainTex );
               

                float Alpha = ( tex2DNode13.a * 1.0 );
                float AlphaClipThreshold = _AlphaClip;
                #ifdef ASE_DEPTH_WRITE_ON
                    float DepthValue = 0;
                #endif

                #ifdef _ALPHATEST_ON
                    clip(Alpha - AlphaClipThreshold);
                #endif

                #ifdef LOD_FADE_CROSSFADE
                    LODDitheringTransition( IN.clipPos.xyz, unity_LODFade.x );
                #endif

                #ifdef ASE_DEPTH_WRITE_ON
                    outputDepth = DepthValue;
                #endif

                return 0;
            }
            ENDHLSL
        }

       
        Pass
        {
           
            Name "Meta"
            Tags { "LightMode"="Meta" }

            Cull Off

            HLSLPROGRAM

            #define _NORMAL_DROPOFF_TS 1
            #define ASE_FOG 1
            #define _ALPHATEST_SHADOW_ON 1
            #define _ALPHATEST_ON 1
            #define ASE_SRP_VERSION 120107


            #pragma vertex vert
            #pragma fragment frag

            #pragma shader_feature EDITOR_VISUALIZATION

            #define SHADERPASS SHADERPASS_META

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/MetaInput.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl"

           

            struct VertexInput
            {
                float4 vertex : POSITION;
                float3 ase_normal : NORMAL;
                float4 texcoord0 : TEXCOORD0;
                float4 texcoord1 : TEXCOORD1;
                float4 texcoord2 : TEXCOORD2;
               
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct VertexOutput
            {
                float4 clipPos : SV_POSITION;
                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    float3 worldPos : TEXCOORD0;
                #endif
                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR) && defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    float4 shadowCoord : TEXCOORD1;
                #endif
                #ifdef EDITOR_VISUALIZATION
                    float4 VizUV : TEXCOORD2;
                    float4 LightCoord : TEXCOORD3;
                #endif
                float4 ase_texcoord4 : TEXCOORD4;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            CBUFFER_START(UnityPerMaterial)
            float4 _MainTex_ST;
            float _ZWriteMode;
            int _ZTestMode;
            float _StencilValue;
            float _AlphaClip;
            float _ShadowAlphaClip;
            #ifdef ASE_TRANSMISSION
                float _TransmissionShadow;
            #endif
            #ifdef ASE_TRANSLUCENCY
                float _TransStrength;
                float _TransNormal;
                float _TransScattering;
                float _TransDirect;
                float _TransAmbient;
                float _TransShadow;
            #endif
            #ifdef ASE_TESSELLATION
                float _TessPhongStrength;
                float _TessValue;
                float _TessMin;
                float _TessMax;
                float _TessEdgeLength;
                float _TessMaxDisp;
            #endif
            CBUFFER_END

            // Property used by ScenePickingPass
            #ifdef SCENEPICKINGPASS
                float4 _SelectionID;
            #endif

            // Properties used by SceneSelectionPass
            #ifdef SCENESELECTIONPASS
                int _ObjectId;
                int _PassValue;
            #endif

            sampler2D _MainTex;


            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Varyings.hlsl"
            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/LightingMetaPass.hlsl"

            //#ifdef HAVE_VFX_MODIFICATION
            //#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/VisualEffectVertex.hlsl"
            //#endif

           
            VertexOutput VertexFunction( VertexInput v  )
            {
                VertexOutput o = (VertexOutput)0;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

                o.ase_texcoord4.xy = v.texcoord0.xy;
               
                //setting value to unused interpolator channels and avoid initialization warnings
                o.ase_texcoord4.zw = 0;

                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    float3 defaultVertexValue = v.vertex.xyz;
                #else
                    float3 defaultVertexValue = float3(0, 0, 0);
                #endif

                float3 vertexValue = defaultVertexValue;

                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    v.vertex.xyz = vertexValue;
                #else
                    v.vertex.xyz += vertexValue;
                #endif

                v.ase_normal = v.ase_normal;

                float3 positionWS = TransformObjectToWorld( v.vertex.xyz );

                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    o.worldPos = positionWS;
                #endif

                o.clipPos = MetaVertexPosition( v.vertex, v.texcoord1.xy, v.texcoord1.xy, unity_LightmapST, unity_DynamicLightmapST );

                #ifdef EDITOR_VISUALIZATION
                    float2 VizUV = 0;
                    float4 LightCoord = 0;
                    UnityEditorVizData(v.vertex.xyz, v.texcoord0.xy, v.texcoord1.xy, v.texcoord2.xy, VizUV, LightCoord);
                    o.VizUV = float4(VizUV, 0, 0);
                    o.LightCoord = LightCoord;
                #endif

                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR) && defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    VertexPositionInputs vertexInput = (VertexPositionInputs)0;
                    vertexInput.positionWS = positionWS;
                    vertexInput.positionCS = o.clipPos;
                    o.shadowCoord = GetShadowCoord( vertexInput );
                #endif

                return o;
            }

            #if defined(ASE_TESSELLATION)
            struct VertexControl
            {
                float4 vertex : INTERNALTESSPOS;
                float3 ase_normal : NORMAL;
                float4 texcoord0 : TEXCOORD0;
                float4 texcoord1 : TEXCOORD1;
                float4 texcoord2 : TEXCOORD2;
               
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct TessellationFactors
            {
                float edge[3] : SV_TessFactor;
                float inside : SV_InsideTessFactor;
            };

            VertexControl vert ( VertexInput v )
            {
                VertexControl o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                o.vertex = v.vertex;
                o.ase_normal = v.ase_normal;
                o.texcoord0 = v.texcoord0;
                o.texcoord1 = v.texcoord1;
                o.texcoord2 = v.texcoord2;
               
                return o;
            }

            TessellationFactors TessellationFunction (InputPatch<VertexControl,3> v)
            {
                TessellationFactors o;
                float4 tf = 1;
                float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax;
                float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp;
                #if defined(ASE_FIXED_TESSELLATION)
                tf = FixedTess( tessValue );
                #elif defined(ASE_DISTANCE_TESSELLATION)
                tf = DistanceBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos );
                #elif defined(ASE_LENGTH_TESSELLATION)
                tf = EdgeLengthBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams );
                #elif defined(ASE_LENGTH_CULL_TESSELLATION)
                tf = EdgeLengthBasedTessCull(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes );
                #endif
                o.edge[0] = tf.x; o.edge[1] = tf.y; o.edge[2] = tf.z; o.inside = tf.w;
                return o;
            }

            [domain("tri")]
            [partitioning("fractional_odd")]
            [outputtopology("triangle_cw")]
            [patchconstantfunc("TessellationFunction")]
            [outputcontrolpoints(3)]
            VertexControl HullFunction(InputPatch<VertexControl, 3> patch, uint id : SV_OutputControlPointID)
            {
                return patch[id];
            }

            [domain("tri")]
            VertexOutput DomainFunction(TessellationFactors factors, OutputPatch<VertexControl, 3> patch, float3 bary : SV_DomainLocation)
            {
                VertexInput o = (VertexInput) 0;
                o.vertex = patch[0].vertex * bary.x + patch[1].vertex * bary.y + patch[2].vertex * bary.z;
                o.ase_normal = patch[0].ase_normal * bary.x + patch[1].ase_normal * bary.y + patch[2].ase_normal * bary.z;
                o.texcoord0 = patch[0].texcoord0 * bary.x + patch[1].texcoord0 * bary.y + patch[2].texcoord0 * bary.z;
                o.texcoord1 = patch[0].texcoord1 * bary.x + patch[1].texcoord1 * bary.y + patch[2].texcoord1 * bary.z;
                o.texcoord2 = patch[0].texcoord2 * bary.x + patch[1].texcoord2 * bary.y + patch[2].texcoord2 * bary.z;
               
                #if defined(ASE_PHONG_TESSELLATION)
                float3 pp[3];
                for (int i = 0; i < 3; ++i)
                    pp[i] = o.vertex.xyz - patch[i].ase_normal * (dot(o.vertex.xyz, patch[i].ase_normal) - dot(patch[i].vertex.xyz, patch[i].ase_normal));
                float phongStrength = _TessPhongStrength;
                o.vertex.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * o.vertex.xyz;
                #endif
                UNITY_TRANSFER_INSTANCE_ID(patch[0], o);
                return VertexFunction(o);
            }
            #else
            VertexOutput vert ( VertexInput v )
            {
                return VertexFunction( v );
            }
            #endif

            half4 frag(VertexOutput IN  ) : SV_TARGET
            {
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX( IN );

                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    float3 WorldPosition = IN.worldPos;
                #endif

                float4 ShadowCoords = float4( 0, 0, 0, 0 );

                #if defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                        ShadowCoords = IN.shadowCoord;
                    #elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
                        ShadowCoords = TransformWorldToShadowCoord( WorldPosition );
                    #endif
                #endif

                float2 uv_MainTex = IN.ase_texcoord4.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                float4 tex2DNode13 = tex2D( _MainTex, uv_MainTex );
               

                float3 BaseColor = tex2DNode13.rgb;
                float3 Emission = 0;
                float Alpha = ( tex2DNode13.a * 1.0 );
                float AlphaClipThreshold = _AlphaClip;

                #ifdef _ALPHATEST_ON
                    clip(Alpha - AlphaClipThreshold);
                #endif

                MetaInput metaInput = (MetaInput)0;
                metaInput.Albedo = BaseColor;
                metaInput.Emission = Emission;
                #ifdef EDITOR_VISUALIZATION
                    metaInput.VizUV = IN.VizUV.xy;
                    metaInput.LightCoord = IN.LightCoord;
                #endif

                return UnityMetaFragment(metaInput);
            }
            ENDHLSL
        }

       
        Pass
        {
           
            Name "DepthNormals"
            Tags { "LightMode"="DepthNormals" }

            ZWrite On
            Blend One Zero
            ZTest LEqual
            ZWrite On

            HLSLPROGRAM

            #define _NORMAL_DROPOFF_TS 1
            #pragma multi_compile_instancing
            #pragma multi_compile_fragment _ LOD_FADE_CROSSFADE
            #define ASE_FOG 1
            #define _ALPHATEST_SHADOW_ON 1
            #define _ALPHATEST_ON 1
            #define ASE_SRP_VERSION 120107


            #pragma vertex vert
            #pragma fragment frag

            #define SHADERPASS SHADERPASS_DEPTHNORMALSONLY

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl"

           

            struct VertexInput
            {
                float4 vertex : POSITION;
                float3 ase_normal : NORMAL;
                float4 ase_tangent : TANGENT;
                float4 ase_texcoord : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct VertexOutput
            {
                float4 clipPos : SV_POSITION;
                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    float3 worldPos : TEXCOORD0;
                #endif
                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR) && defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    float4 shadowCoord : TEXCOORD1;
                #endif
                float3 worldNormal : TEXCOORD2;
                float4 worldTangent : TEXCOORD3;
                float4 ase_texcoord4 : TEXCOORD4;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            CBUFFER_START(UnityPerMaterial)
            float4 _MainTex_ST;
            float _ZWriteMode;
            int _ZTestMode;
            float _StencilValue;
            float _AlphaClip;
            float _ShadowAlphaClip;
            #ifdef ASE_TRANSMISSION
                float _TransmissionShadow;
            #endif
            #ifdef ASE_TRANSLUCENCY
                float _TransStrength;
                float _TransNormal;
                float _TransScattering;
                float _TransDirect;
                float _TransAmbient;
                float _TransShadow;
            #endif
            #ifdef ASE_TESSELLATION
                float _TessPhongStrength;
                float _TessValue;
                float _TessMin;
                float _TessMax;
                float _TessEdgeLength;
                float _TessMaxDisp;
            #endif
            CBUFFER_END

            // Property used by ScenePickingPass
            #ifdef SCENEPICKINGPASS
                float4 _SelectionID;
            #endif

            // Properties used by SceneSelectionPass
            #ifdef SCENESELECTIONPASS
                int _ObjectId;
                int _PassValue;
            #endif

            sampler2D _MainTex;


            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Varyings.hlsl"
            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/DepthNormalsOnlyPass.hlsl"

            //#ifdef HAVE_VFX_MODIFICATION
            //#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/VisualEffectVertex.hlsl"
            //#endif

           
            VertexOutput VertexFunction( VertexInput v  )
            {
                VertexOutput o = (VertexOutput)0;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

                o.ase_texcoord4.xy = v.ase_texcoord.xy;
               
                //setting value to unused interpolator channels and avoid initialization warnings
                o.ase_texcoord4.zw = 0;
                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    float3 defaultVertexValue = v.vertex.xyz;
                #else
                    float3 defaultVertexValue = float3(0, 0, 0);
                #endif

                float3 vertexValue = defaultVertexValue;

                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    v.vertex.xyz = vertexValue;
                #else
                    v.vertex.xyz += vertexValue;
                #endif

                v.ase_normal = v.ase_normal;
                float3 positionWS = TransformObjectToWorld( v.vertex.xyz );
                float3 normalWS = TransformObjectToWorldNormal( v.ase_normal );
                float4 tangentWS = float4(TransformObjectToWorldDir( v.ase_tangent.xyz), v.ase_tangent.w);
                float4 positionCS = TransformWorldToHClip( positionWS );

                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    o.worldPos = positionWS;
                #endif

                o.worldNormal = normalWS;
                o.worldTangent = tangentWS;

                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR) && defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    VertexPositionInputs vertexInput = (VertexPositionInputs)0;
                    vertexInput.positionWS = positionWS;
                    vertexInput.positionCS = positionCS;
                    o.shadowCoord = GetShadowCoord( vertexInput );
                #endif

                o.clipPos = positionCS;

                return o;
            }

            #if defined(ASE_TESSELLATION)
            struct VertexControl
            {
                float4 vertex : INTERNALTESSPOS;
                float3 ase_normal : NORMAL;
                float4 ase_tangent : TANGENT;
                float4 ase_texcoord : TEXCOORD0;

                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct TessellationFactors
            {
                float edge[3] : SV_TessFactor;
                float inside : SV_InsideTessFactor;
            };

            VertexControl vert ( VertexInput v )
            {
                VertexControl o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                o.vertex = v.vertex;
                o.ase_normal = v.ase_normal;
                o.ase_tangent = v.ase_tangent;
                o.ase_texcoord = v.ase_texcoord;
                return o;
            }

            TessellationFactors TessellationFunction (InputPatch<VertexControl,3> v)
            {
                TessellationFactors o;
                float4 tf = 1;
                float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax;
                float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp;
                #if defined(ASE_FIXED_TESSELLATION)
                tf = FixedTess( tessValue );
                #elif defined(ASE_DISTANCE_TESSELLATION)
                tf = DistanceBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos );
                #elif defined(ASE_LENGTH_TESSELLATION)
                tf = EdgeLengthBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams );
                #elif defined(ASE_LENGTH_CULL_TESSELLATION)
                tf = EdgeLengthBasedTessCull(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes );
                #endif
                o.edge[0] = tf.x; o.edge[1] = tf.y; o.edge[2] = tf.z; o.inside = tf.w;
                return o;
            }

            [domain("tri")]
            [partitioning("fractional_odd")]
            [outputtopology("triangle_cw")]
            [patchconstantfunc("TessellationFunction")]
            [outputcontrolpoints(3)]
            VertexControl HullFunction(InputPatch<VertexControl, 3> patch, uint id : SV_OutputControlPointID)
            {
                return patch[id];
            }

            [domain("tri")]
            VertexOutput DomainFunction(TessellationFactors factors, OutputPatch<VertexControl, 3> patch, float3 bary : SV_DomainLocation)
            {
                VertexInput o = (VertexInput) 0;
                o.vertex = patch[0].vertex * bary.x + patch[1].vertex * bary.y + patch[2].vertex * bary.z;
                o.ase_normal = patch[0].ase_normal * bary.x + patch[1].ase_normal * bary.y + patch[2].ase_normal * bary.z;
                o.ase_tangent = patch[0].ase_tangent * bary.x + patch[1].ase_tangent * bary.y + patch[2].ase_tangent * bary.z;
                o.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z;
                #if defined(ASE_PHONG_TESSELLATION)
                float3 pp[3];
                for (int i = 0; i < 3; ++i)
                    pp[i] = o.vertex.xyz - patch[i].ase_normal * (dot(o.vertex.xyz, patch[i].ase_normal) - dot(patch[i].vertex.xyz, patch[i].ase_normal));
                float phongStrength = _TessPhongStrength;
                o.vertex.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * o.vertex.xyz;
                #endif
                UNITY_TRANSFER_INSTANCE_ID(patch[0], o);
                return VertexFunction(o);
            }
            #else
            VertexOutput vert ( VertexInput v )
            {
                return VertexFunction( v );
            }
            #endif

            #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE)
                #define ASE_SV_DEPTH SV_DepthLessEqual
            #else
                #define ASE_SV_DEPTH SV_Depth
            #endif

            half4 frag(    VertexOutput IN
                        #ifdef ASE_DEPTH_WRITE_ON
                        ,out float outputDepth : ASE_SV_DEPTH
                        #endif
                         ) : SV_TARGET
            {
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX( IN );

                #if defined(ASE_NEEDS_FRAG_WORLD_POSITION)
                    float3 WorldPosition = IN.worldPos;
                #endif

                float4 ShadowCoords = float4( 0, 0, 0, 0 );
                float3 WorldNormal = IN.worldNormal;
                float4 WorldTangent = IN.worldTangent;

                #if defined(ASE_NEEDS_FRAG_SHADOWCOORDS)
                    #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                        ShadowCoords = IN.shadowCoord;
                    #elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
                        ShadowCoords = TransformWorldToShadowCoord( WorldPosition );
                    #endif
                #endif

                float2 uv_MainTex = IN.ase_texcoord4.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                float4 tex2DNode13 = tex2D( _MainTex, uv_MainTex );
               

                float3 Normal = float3(0, 0, 1);
                float Alpha = ( tex2DNode13.a * 1.0 );
                float AlphaClipThreshold = _AlphaClip;
                #ifdef ASE_DEPTH_WRITE_ON
                    float DepthValue = 0;
                #endif

                #ifdef _ALPHATEST_ON
                    clip(Alpha - AlphaClipThreshold);
                #endif

                #ifdef LOD_FADE_CROSSFADE
                    LODDitheringTransition( IN.clipPos.xyz, unity_LODFade.x );
                #endif

                #ifdef ASE_DEPTH_WRITE_ON
                    outputDepth = DepthValue;
                #endif

                #if defined(_GBUFFER_NORMALS_OCT)
                    float2 octNormalWS = PackNormalOctQuadEncode(WorldNormal);
                    float2 remappedOctNormalWS = saturate(octNormalWS * 0.5 + 0.5);
                    half3 packedNormalWS = PackFloat2To888(remappedOctNormalWS);
                    return half4(packedNormalWS, 0.0);
                #else
                    #if defined(_NORMALMAP)
                        #if _NORMAL_DROPOFF_TS
                            float crossSign = (WorldTangent.w > 0.0 ? 1.0 : -1.0) * GetOddNegativeScale();
                            float3 bitangent = crossSign * cross(WorldNormal.xyz, WorldTangent.xyz);
                            float3 normalWS = TransformTangentToWorld(Normal, half3x3(WorldTangent.xyz, bitangent, WorldNormal.xyz));
                        #elif _NORMAL_DROPOFF_OS
                            float3 normalWS = TransformObjectToWorldNormal(Normal);
                        #elif _NORMAL_DROPOFF_WS
                            float3 normalWS = Normal;
                        #endif
                    #else
                        float3 normalWS = WorldNormal;
                    #endif
                    return half4(NormalizeNormalPerPixel(normalWS), 0.0);
                #endif
            }
            ENDHLSL
        }

       
        Pass
        {
           
            Name "GBuffer"
            Tags { "LightMode"="UniversalGBuffer" }

            Blend One Zero, One Zero
            ZWrite 1
            ZTest 0
            Offset 0 , 0
            ColorMask RGBA
            Stencil
            {
                Ref 0
                Comp Always
                Pass Replace
            }

            HLSLPROGRAM

            #define _NORMAL_DROPOFF_TS 1
            #pragma multi_compile_instancing
            #pragma instancing_options renderinglayer
            #pragma multi_compile_fragment _ LOD_FADE_CROSSFADE
            #pragma multi_compile_fog
            #define ASE_FOG 1
            #define _ALPHATEST_SHADOW_ON 1
            #define _ALPHATEST_ON 1
            #define ASE_SRP_VERSION 120107


            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
            #pragma multi_compile_fragment _ _REFLECTION_PROBE_BLENDING
            #pragma multi_compile_fragment _ _REFLECTION_PROBE_BOX_PROJECTION
            #pragma multi_compile_fragment _ _SHADOWS_SOFT
            #pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3
            #pragma multi_compile_fragment _ _LIGHT_LAYERS
            #pragma multi_compile_fragment _ _RENDER_PASS_ENABLED
            #pragma shader_feature_local _RECEIVE_SHADOWS_OFF
            #pragma shader_feature_local_fragment _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local_fragment _ENVIRONMENTREFLECTIONS_OFF

            #pragma multi_compile _ LIGHTMAP_SHADOW_MIXING
            #pragma multi_compile _ SHADOWS_SHADOWMASK
            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
            #pragma multi_compile _ LIGHTMAP_ON
            #pragma multi_compile _ DYNAMICLIGHTMAP_ON
            #pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT

            #pragma vertex vert
            #pragma fragment frag

            #define SHADERPASS SHADERPASS_GBUFFER

            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DBuffer.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl"

            #if defined(UNITY_INSTANCING_ENABLED) && defined(_TERRAIN_INSTANCED_PERPIXEL_NORMAL)
                #define ENABLE_TERRAIN_PERPIXEL_NORMAL
            #endif

           

            struct VertexInput
            {
                float4 vertex : POSITION;
                float3 ase_normal : NORMAL;
                float4 ase_tangent : TANGENT;
                float4 texcoord : TEXCOORD0;
                float4 texcoord1 : TEXCOORD1;
                float4 texcoord2 : TEXCOORD2;
               
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct VertexOutput
            {
                float4 clipPos : SV_POSITION;
                float4 lightmapUVOrVertexSH : TEXCOORD0;
                half4 fogFactorAndVertexLight : TEXCOORD1;
                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                float4 shadowCoord : TEXCOORD2;
                #endif
                float4 tSpace0 : TEXCOORD3;
                float4 tSpace1 : TEXCOORD4;
                float4 tSpace2 : TEXCOORD5;
                #if defined(ASE_NEEDS_FRAG_SCREEN_POSITION)
                float4 screenPos : TEXCOORD6;
                #endif
                #if defined(DYNAMICLIGHTMAP_ON)
                float2 dynamicLightmapUV : TEXCOORD7;
                #endif
                float4 ase_texcoord8 : TEXCOORD8;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            CBUFFER_START(UnityPerMaterial)
            float4 _MainTex_ST;
            float _ZWriteMode;
            int _ZTestMode;
            float _StencilValue;
            float _AlphaClip;
            float _ShadowAlphaClip;
            #ifdef ASE_TRANSMISSION
                float _TransmissionShadow;
            #endif
            #ifdef ASE_TRANSLUCENCY
                float _TransStrength;
                float _TransNormal;
                float _TransScattering;
                float _TransDirect;
                float _TransAmbient;
                float _TransShadow;
            #endif
            #ifdef ASE_TESSELLATION
                float _TessPhongStrength;
                float _TessValue;
                float _TessMin;
                float _TessMax;
                float _TessEdgeLength;
                float _TessMaxDisp;
            #endif
            CBUFFER_END

            // Property used by ScenePickingPass
            #ifdef SCENEPICKINGPASS
                float4 _SelectionID;
            #endif

            // Properties used by SceneSelectionPass
            #ifdef SCENESELECTIONPASS
                int _ObjectId;
                int _PassValue;
            #endif

            sampler2D _MainTex;


            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/Varyings.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/UnityGBuffer.hlsl"
            //#include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/PBRGBufferPass.hlsl"

           
            VertexOutput VertexFunction( VertexInput v  )
            {
                VertexOutput o = (VertexOutput)0;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

                o.ase_texcoord8.xy = v.texcoord.xy;
               
                //setting value to unused interpolator channels and avoid initialization warnings
                o.ase_texcoord8.zw = 0;
                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    float3 defaultVertexValue = v.vertex.xyz;
                #else
                    float3 defaultVertexValue = float3(0, 0, 0);
                #endif

                float3 vertexValue = defaultVertexValue;

                #ifdef ASE_ABSOLUTE_VERTEX_POS
                    v.vertex.xyz = vertexValue;
                #else
                    v.vertex.xyz += vertexValue;
                #endif

                v.ase_normal = v.ase_normal;

                float3 positionWS = TransformObjectToWorld( v.vertex.xyz );
                float3 positionVS = TransformWorldToView( positionWS );
                float4 positionCS = TransformWorldToHClip( positionWS );

                VertexNormalInputs normalInput = GetVertexNormalInputs( v.ase_normal, v.ase_tangent );

                o.tSpace0 = float4( normalInput.normalWS, positionWS.x);
                o.tSpace1 = float4( normalInput.tangentWS, positionWS.y);
                o.tSpace2 = float4( normalInput.bitangentWS, positionWS.z);

                #if defined(LIGHTMAP_ON)
                    OUTPUT_LIGHTMAP_UV(v.texcoord1, unity_LightmapST, o.lightmapUVOrVertexSH.xy);
                #endif

                #if defined(DYNAMICLIGHTMAP_ON)
                    o.dynamicLightmapUV.xy = v.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
                #endif

                #if !defined(LIGHTMAP_ON)
                    OUTPUT_SH(normalInput.normalWS.xyz, o.lightmapUVOrVertexSH.xyz);
                #endif

                #if defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)
                    o.lightmapUVOrVertexSH.zw = v.texcoord;
                    o.lightmapUVOrVertexSH.xy = v.texcoord * unity_LightmapST.xy + unity_LightmapST.zw;
                #endif

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

                o.fogFactorAndVertexLight = half4(0, vertexLight);

                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                    VertexPositionInputs vertexInput = (VertexPositionInputs)0;
                    vertexInput.positionWS = positionWS;
                    vertexInput.positionCS = positionCS;
                    o.shadowCoord = GetShadowCoord( vertexInput );
                #endif

                    o.clipPos = positionCS;

                #if defined(ASE_NEEDS_FRAG_SCREEN_POSITION)
                    o.screenPos = ComputeScreenPos(positionCS);
                #endif

                return o;
            }

            #if defined(ASE_TESSELLATION)
            struct VertexControl
            {
                float4 vertex : INTERNALTESSPOS;
                float3 ase_normal : NORMAL;
                float4 ase_tangent : TANGENT;
                float4 texcoord : TEXCOORD0;
                float4 texcoord1 : TEXCOORD1;
                float4 texcoord2 : TEXCOORD2;
               
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct TessellationFactors
            {
                float edge[3] : SV_TessFactor;
                float inside : SV_InsideTessFactor;
            };

            VertexControl vert ( VertexInput v )
            {
                VertexControl o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_TRANSFER_INSTANCE_ID(v, o);
                o.vertex = v.vertex;
                o.ase_normal = v.ase_normal;
                o.ase_tangent = v.ase_tangent;
                o.texcoord = v.texcoord;
                o.texcoord1 = v.texcoord1;
                o.texcoord2 = v.texcoord2;
               
                return o;
            }

            TessellationFactors TessellationFunction (InputPatch<VertexControl,3> v)
            {
                TessellationFactors o;
                float4 tf = 1;
                float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax;
                float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp;
                #if defined(ASE_FIXED_TESSELLATION)
                tf = FixedTess( tessValue );
                #elif defined(ASE_DISTANCE_TESSELLATION)
                tf = DistanceBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos );
                #elif defined(ASE_LENGTH_TESSELLATION)
                tf = EdgeLengthBasedTess(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams );
                #elif defined(ASE_LENGTH_CULL_TESSELLATION)
                tf = EdgeLengthBasedTessCull(v[0].vertex, v[1].vertex, v[2].vertex, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes );
                #endif
                o.edge[0] = tf.x; o.edge[1] = tf.y; o.edge[2] = tf.z; o.inside = tf.w;
                return o;
            }

            [domain("tri")]
            [partitioning("fractional_odd")]
            [outputtopology("triangle_cw")]
            [patchconstantfunc("TessellationFunction")]
            [outputcontrolpoints(3)]
            VertexControl HullFunction(InputPatch<VertexControl, 3> patch, uint id : SV_OutputControlPointID)
            {
                return patch[id];
            }

            [domain("tri")]
            VertexOutput DomainFunction(TessellationFactors factors, OutputPatch<VertexControl, 3> patch, float3 bary : SV_DomainLocation)
            {
                VertexInput o = (VertexInput) 0;
                o.vertex = patch[0].vertex * bary.x + patch[1].vertex * bary.y + patch[2].vertex * bary.z;
                o.ase_normal = patch[0].ase_normal * bary.x + patch[1].ase_normal * bary.y + patch[2].ase_normal * bary.z;
                o.ase_tangent = patch[0].ase_tangent * bary.x + patch[1].ase_tangent * bary.y + patch[2].ase_tangent * bary.z;
                o.texcoord = patch[0].texcoord * bary.x + patch[1].texcoord * bary.y + patch[2].texcoord * bary.z;
                o.texcoord1 = patch[0].texcoord1 * bary.x + patch[1].texcoord1 * bary.y + patch[2].texcoord1 * bary.z;
                o.texcoord2 = patch[0].texcoord2 * bary.x + patch[1].texcoord2 * bary.y + patch[2].texcoord2 * bary.z;
               
                #if defined(ASE_PHONG_TESSELLATION)
                float3 pp[3];
                for (int i = 0; i < 3; ++i)
                    pp[i] = o.vertex.xyz - patch[i].ase_normal * (dot(o.vertex.xyz, patch[i].ase_normal) - dot(patch[i].vertex.xyz, patch[i].ase_normal));
                float phongStrength = _TessPhongStrength;
                o.vertex.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * o.vertex.xyz;
                #endif
                UNITY_TRANSFER_INSTANCE_ID(patch[0], o);
                return VertexFunction(o);
            }
            #else
            VertexOutput vert ( VertexInput v )
            {
                return VertexFunction( v );
            }
            #endif

            #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE)
                #define ASE_SV_DEPTH SV_DepthLessEqual
            #else
                #define ASE_SV_DEPTH SV_Depth
            #endif

            FragmentOutput frag ( VertexOutput IN
                                #ifdef ASE_DEPTH_WRITE_ON
                                ,out float outputDepth : ASE_SV_DEPTH
                                #endif
                                 )
            {
                UNITY_SETUP_INSTANCE_ID(IN);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(IN);

                #ifdef LOD_FADE_CROSSFADE
                    LODDitheringTransition( IN.clipPos.xyz, unity_LODFade.x );
                #endif

                #if defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)
                    float2 sampleCoords = (IN.lightmapUVOrVertexSH.zw / _TerrainHeightmapRecipSize.zw + 0.5f) * _TerrainHeightmapRecipSize.xy;
                    float3 WorldNormal = TransformObjectToWorldNormal(normalize(SAMPLE_TEXTURE2D(_TerrainNormalmapTexture, sampler_TerrainNormalmapTexture, sampleCoords).rgb * 2 - 1));
                    float3 WorldTangent = -cross(GetObjectToWorldMatrix()._13_23_33, WorldNormal);
                    float3 WorldBiTangent = cross(WorldNormal, -WorldTangent);
                #else
                    float3 WorldNormal = normalize( IN.tSpace0.xyz );
                    float3 WorldTangent = IN.tSpace1.xyz;
                    float3 WorldBiTangent = IN.tSpace2.xyz;
                #endif

                float3 WorldPosition = float3(IN.tSpace0.w,IN.tSpace1.w,IN.tSpace2.w);
                float3 WorldViewDirection = _WorldSpaceCameraPos.xyz  - WorldPosition;
                float4 ShadowCoords = float4( 0, 0, 0, 0 );

                #if defined(ASE_NEEDS_FRAG_SCREEN_POSITION)
                    float4 ScreenPos = IN.screenPos;
                #endif

                float2 NormalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(IN.clipPos);

                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                    ShadowCoords = IN.shadowCoord;
                #elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
                    ShadowCoords = TransformWorldToShadowCoord( WorldPosition );
                #else
                    ShadowCoords = float4(0, 0, 0, 0);
                #endif

                WorldViewDirection = SafeNormalize( WorldViewDirection );

                float2 uv_MainTex = IN.ase_texcoord8.xy * _MainTex_ST.xy + _MainTex_ST.zw;
                float4 tex2DNode13 = tex2D( _MainTex, uv_MainTex );
               

                float3 BaseColor = tex2DNode13.rgb;
                float3 Normal = float3(0, 0, 1);
                float3 Emission = 0;
                float3 Specular = 0.5;
                float Metallic = 0.0;
                float Smoothness = 0.0;
                float Occlusion = 1.0;
                float Alpha = ( tex2DNode13.a * 1.0 );
                float AlphaClipThreshold = _AlphaClip;
                float AlphaClipThresholdShadow = _ShadowAlphaClip;
                float3 BakedGI = 0;
                float3 RefractionColor = 1;
                float RefractionIndex = 1;
                float3 Transmission = 1;
                float3 Translucency = 1;

                #ifdef ASE_DEPTH_WRITE_ON
                    float DepthValue = 0;
                #endif

                #ifdef _ALPHATEST_ON
                    clip(Alpha - AlphaClipThreshold);
                #endif

                InputData inputData = (InputData)0;
                inputData.positionWS = WorldPosition;
                inputData.positionCS = IN.clipPos;
                inputData.shadowCoord = ShadowCoords;

                #ifdef _NORMALMAP
                    #if _NORMAL_DROPOFF_TS
                        inputData.normalWS = TransformTangentToWorld(Normal, half3x3( WorldTangent, WorldBiTangent, WorldNormal ));
                    #elif _NORMAL_DROPOFF_OS
                        inputData.normalWS = TransformObjectToWorldNormal(Normal);
                    #elif _NORMAL_DROPOFF_WS
                        inputData.normalWS = Normal;
                    #endif
                #else
                    inputData.normalWS = WorldNormal;
                #endif

                inputData.normalWS = NormalizeNormalPerPixel(inputData.normalWS);
                inputData.viewDirectionWS = SafeNormalize( WorldViewDirection );

                inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;

                #if defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)
                    float3 SH = SampleSH(inputData.normalWS.xyz);
                #else
                    float3 SH = IN.lightmapUVOrVertexSH.xyz;
                #endif

                #ifdef ASE_BAKEDGI
                    inputData.bakedGI = BakedGI;
                #else
                    #if defined(DYNAMICLIGHTMAP_ON)
                        inputData.bakedGI = SAMPLE_GI( IN.lightmapUVOrVertexSH.xy, IN.dynamicLightmapUV.xy, SH, inputData.normalWS);
                    #else
                        inputData.bakedGI = SAMPLE_GI( IN.lightmapUVOrVertexSH.xy, SH, inputData.normalWS );
                    #endif
                #endif

                inputData.normalizedScreenSpaceUV = NormalizedScreenSpaceUV;
                inputData.shadowMask = SAMPLE_SHADOWMASK(IN.lightmapUVOrVertexSH.xy);

                #if defined(DEBUG_DISPLAY)
                    #if defined(DYNAMICLIGHTMAP_ON)
                        inputData.dynamicLightmapUV = IN.dynamicLightmapUV.xy;
                        #endif
                    #if defined(LIGHTMAP_ON)
                        inputData.staticLightmapUV = IN.lightmapUVOrVertexSH.xy;
                    #else
                        inputData.vertexSH = SH;
                    #endif
                #endif

                #ifdef _DBUFFER
                    ApplyDecal(IN.clipPos,
                        BaseColor,
                        Specular,
                        inputData.normalWS,
                        Metallic,
                        Occlusion,
                        Smoothness);
                #endif

                BRDFData brdfData;
                InitializeBRDFData
                (BaseColor, Metallic, Specular, Smoothness, Alpha, brdfData);

                Light mainLight = GetMainLight(inputData.shadowCoord, inputData.positionWS, inputData.shadowMask);
                half4 color;
                MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, inputData.shadowMask);
                color.rgb = GlobalIllumination(brdfData, inputData.bakedGI, Occlusion, inputData.positionWS, inputData.normalWS, inputData.viewDirectionWS);
                color.a = Alpha;

                #ifdef ASE_FINAL_COLOR_ALPHA_MULTIPLY
                    color.rgb *= color.a;
                #endif

                #ifdef ASE_DEPTH_WRITE_ON
                    outputDepth = DepthValue;
                #endif

                return BRDFDataToGbuffer(brdfData, inputData, Smoothness, Emission + color.rgb, Occlusion);
            }

            ENDHLSL
        }

   
    }
   
    CustomEditor "UnityEditor.ShaderGraphLitGUI"
    FallBack "Hidden/Shader Graph/FallbackError"
   
    Fallback Off
}
/*ASEBEGIN
Version=19105
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;0;0,0;Float;False;False;-1;2;UnityEditor.ShaderGraphLitGUI;0;1;New Amplify Shader;94348b07e5e8bab40bd6c8a1e3df54cd;True;ExtraPrePass;0;0;ExtraPrePass;5;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;True;1;1;False;;0;False;;0;1;False;;0;False;;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;True;True;True;True;0;False;;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;0;False;False;0;;0;0;Standard;0;False;0
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;2;0,0;Float;False;False;-1;2;UnityEditor.ShaderGraphLitGUI;0;1;New Amplify Shader;94348b07e5e8bab40bd6c8a1e3df54cd;True;ShadowCaster;0;2;ShadowCaster;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;False;False;True;False;False;False;False;0;False;;False;False;False;False;False;False;False;False;False;True;1;False;;True;3;False;;False;True;1;LightMode=ShadowCaster;False;False;0;;0;0;Standard;0;False;0
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;3;0,0;Float;False;False;-1;2;UnityEditor.ShaderGraphLitGUI;0;1;New Amplify Shader;94348b07e5e8bab40bd6c8a1e3df54cd;True;DepthOnly;0;3;DepthOnly;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;False;False;True;False;False;False;False;0;False;;False;False;False;False;False;False;False;False;False;True;1;False;;False;False;True;1;LightMode=DepthOnly;False;False;0;;0;0;Standard;0;False;0
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;4;0,0;Float;False;False;-1;2;UnityEditor.ShaderGraphLitGUI;0;1;New Amplify Shader;94348b07e5e8bab40bd6c8a1e3df54cd;True;Meta;0;4;Meta;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;2;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;1;LightMode=Meta;False;False;0;;0;0;Standard;0;False;0
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;5;0,0;Float;False;False;-1;2;UnityEditor.ShaderGraphLitGUI;0;1;New Amplify Shader;94348b07e5e8bab40bd6c8a1e3df54cd;True;Universal2D;0;5;Universal2D;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;True;1;1;False;;0;False;;1;1;False;;0;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;True;True;True;True;0;False;;False;False;False;False;False;False;False;False;False;True;1;True;;True;3;True;;True;True;0;False;;0;False;;True;1;LightMode=Universal2D;False;False;0;;0;0;Standard;0;False;0
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;6;0,0;Float;False;False;-1;2;UnityEditor.ShaderGraphLitGUI;0;1;New Amplify Shader;94348b07e5e8bab40bd6c8a1e3df54cd;True;DepthNormals;0;6;DepthNormals;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;True;1;1;False;;0;False;;0;1;False;;0;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;1;False;;True;3;False;;False;True;1;LightMode=DepthNormals;False;False;0;;0;0;Standard;0;False;0
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;7;0,0;Float;False;False;-1;2;UnityEditor.ShaderGraphLitGUI;0;1;New Amplify Shader;94348b07e5e8bab40bd6c8a1e3df54cd;True;GBuffer;0;7;GBuffer;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;True;1;1;False;;0;False;;1;1;False;;0;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;True;True;True;True;0;False;;False;False;False;False;False;False;False;True;True;0;False;;255;False;;255;False;;7;False;;3;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;0;False;;True;True;0;False;;0;False;;True;1;LightMode=UniversalGBuffer;False;False;0;;0;0;Standard;0;False;0
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;8;0,0;Float;False;False;-1;2;UnityEditor.ShaderGraphLitGUI;0;1;New Amplify Shader;94348b07e5e8bab40bd6c8a1e3df54cd;True;SceneSelectionPass;0;8;SceneSelectionPass;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;2;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;1;LightMode=SceneSelectionPass;False;False;0;;0;0;Standard;0;False;0
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;9;0,0;Float;False;False;-1;2;UnityEditor.ShaderGraphLitGUI;0;1;New Amplify Shader;94348b07e5e8bab40bd6c8a1e3df54cd;True;ScenePickingPass;0;9;ScenePickingPass;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;1;LightMode=Picking;False;False;0;;0;0;Standard;0;False;0
Node;AmplifyShaderEditor.RangedFloatNode;10;-511.6666,149.1667;Inherit;False;Property;_AlphaClip;AlphaClip;3;0;Create;True;0;0;0;False;0;False;0.5;0.5;0;1;0;1;FLOAT;0
Node;AmplifyShaderEditor.RangedFloatNode;11;-506.6666,241.1667;Inherit;False;Property;_ShadowAlphaClip;ShadowAlphaClip;4;0;Create;True;0;0;0;False;0;False;0.5;0.5;0;1;0;1;FLOAT;0
Node;AmplifyShaderEditor.TemplateMultiPassMasterNode;1;0,0;Float;False;True;-1;2;UnityEditor.ShaderGraphLitGUI;0;12;Sh_Main;94348b07e5e8bab40bd6c8a1e3df54cd;True;Forward;0;1;Forward;19;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;True;True;1;False;_ZWriteMode;True;3;False;_ZTestMode;True;True;0;False;;0;False;;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Lit;True;3;True;12;all;0;False;True;1;1;False;;0;False;;1;1;False;;0;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;True;True;True;True;0;False;;False;False;False;False;False;False;True;True;True;0;True;_StencilValue;255;False;;255;False;;7;False;;3;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;True;True;1;True;_ZWriteMode;True;0;True;_ZTestMode;True;True;0;False;;0;False;;True;1;LightMode=UniversalForward;False;False;0;;0;0;Standard;41;Workflow;1;0;Surface;0;0;  Refraction Model;0;0;  Blend;0;0;Two Sided;1;0;Fragment Normal Space,InvertActionOnDeselection;0;0;Forward Only;0;0;Transmission;0;0;  Transmission Shadow;0.5,False,;0;Translucency;0;0;  Translucency Strength;1,False,;0;  Normal Distortion;0.5,False,;0;  Scattering;2,False,;0;  Direct;0.9,False,;0;  Ambient;0.1,False,;0;  Shadow;0.5,False,;0;Cast Shadows;1;0;  Use Shadow Threshold;1;638153065053116221;Receive Shadows;1;0;GPU Instancing;1;0;LOD CrossFade;1;0;Built-in Fog;1;0;_FinalColorxAlpha;0;0;Meta Pass;1;0;Override Baked GI;0;0;Extra Pre Pass;0;0;DOTS Instancing;0;0;Tessellation;0;0;  Phong;0;0;  Strength;0.5,False,;0;  Type;0;0;  Tess;16,False,;0;  Min;10,False,;0;  Max;25,False,;0;  Edge Length;16,False,;0;  Max Displacement;25,False,;0;Write Depth;0;0;  Early Z;0;0;Vertex Position,InvertActionOnDeselection;1;0;Debug Display;0;0;Clear Coat;0;0;0;10;False;True;True;True;True;False;True;True;False;False;False;;False;0
Node;AmplifyShaderEditor.RangedFloatNode;16;325.25,80.28326;Inherit;False;Constant;_Float0;Float 0;4;0;Create;True;0;0;0;False;0;False;0;0;0;0;0;1;FLOAT;0
Node;AmplifyShaderEditor.RangedFloatNode;15;329.75,154.3833;Inherit;False;Constant;_Float1;Float 0;4;0;Create;True;0;0;0;False;0;False;1;0;0;0;0;1;FLOAT;0
Node;AmplifyShaderEditor.SamplerNode;13;-659,-171.1667;Inherit;True;Property;_MainTex;MainTex;2;0;Create;True;0;0;0;False;0;False;-1;None;c399906367248ac458b5e759382bac9c;True;0;False;white;Auto;False;Object;-1;Auto;Texture2D;8;0;SAMPLER2D;;False;1;FLOAT2;0,0;False;2;FLOAT;0;False;3;FLOAT2;0,0;False;4;FLOAT2;0,0;False;5;FLOAT;1;False;6;FLOAT;0;False;7;SAMPLERSTATE;;False;5;COLOR;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4
Node;AmplifyShaderEditor.FunctionNode;19;-655.6666,20.16658;Inherit;False;Shfunc_DissolveEffect;5;;19;2ccf71dc91aaf4347a0bef249fa12cd6;0;0;2;FLOAT;10;COLOR;0
Node;AmplifyShaderEditor.RangedFloatNode;22;-2.745223,472.6603;Inherit;False;Property;_ZWriteMode;ZWriteMode;1;1;[Toggle];Create;True;0;0;0;True;0;False;1;1;0;0;0;1;FLOAT;0
Node;AmplifyShaderEditor.IntNode;20;-7.328074,382.1871;Inherit;False;Property;_ZTestMode;ZTestMode;0;1;[Enum];Create;True;0;0;1;UnityEngine.Rendering.CompareFunction;True;0;False;4;4;True;0;1;INT;0
Node;AmplifyShaderEditor.RangedFloatNode;17;-1.775468,304.2852;Inherit;False;Property;_StencilValue;StencilValue;12;0;Create;True;0;0;0;True;0;False;0;0;0;0;0;1;FLOAT;0
Node;AmplifyShaderEditor.SimpleMultiplyOpNode;14;-284,-3.166702;Inherit;False;2;2;0;FLOAT;0;False;1;FLOAT;1;False;1;FLOAT;0
WireConnection;1;0;13;0
WireConnection;1;3;16;0
WireConnection;1;4;16;0
WireConnection;1;5;15;0
WireConnection;1;6;14;0
WireConnection;1;7;10;0
WireConnection;1;16;11;0
WireConnection;14;0;13;4
ASEEND*/
//CHKSM=64E817EFEDE5B23DF78BABAAA186E633AD4B4446

also _StencilValue will lose in ase editor,but that does’t break the shader.

to fix it you should reset zwrite and ztest in gui,and re compile it then every thing will be correct,but once you close the editor and reopen it and if you compile again,pink comes back

i see this before in some rare cases a shader that was originally made in a very old version.
in the other cases this was due to some bad meta in shader getting left over

please try open “Preferences” and enable the option “Force Template Inline Properties.”
this will force the system to look at the template first and clear any bad left over meta.

be certain to turn this off after your finished with it so future changes do not keep reverting.

if it’s still a issue after this please send me copy thru email 8963691--1231656--upload_2023-4-20_21-55-53.png

that is not work. bug still there
i have already post the shader file,just copy that to you unity.

Hello!
I’m using a URP Unlit Toonshader with SRP Additional Light Node. I want to turn off self shadow while keeping the cast shader and receive shadow on. Can you help me with this?

I ended up just writing it in Shader Forge since I never got a reply.
Did you get it working?

8976847--1234570--upload_2023-4-27_18-59-23.png

we have had a few reports about users with issue for baked shadows.
however, in most cases i was not able to replicate.

I suspect many users have issue with:
— sample should use property name _MainTex
— alpha should come from the sample with property named _MainTex
— Unity shadow atlas resolution is set too low within the render pipeline asset