// 顶点函数
Varyings vert(Attributes input)

// 片元函数
half4 frag(Varyings input) : SV_Target

Shader "Custom/CustomLitShader"
{
    Properties
    {
        [MainTexture] _BaseMap("Base Map", 2D) = "white" {}
        [MainColor] _BaseColor("Base Color", Color) = (1, 1, 1, 1)
        
        _BumpMap("Normal Map", 2D) = "bump" {}
        _BumpScale("Normal Scale", Range(0, 2)) = 1.0
        
        _Metallic("Metallic", Range(0, 1)) = 0.0
        _Smoothness("Smoothness", Range(0, 1)) = 0.5
        _SmoothnessTextureChannel("Smoothness Map Channel", Float) = 0
        
        _SpecColor("Specular Color", Color) = (0.2, 0.2, 0.2, 1)
        _SpecularHighlights("Specular Highlights", Float) = 1.0
        
        [HDR] _EmissionColor("Emission Color", Color) = (0, 0, 0, 1)
        _EmissionMap("Emission Map", 2D) = "white" {}
        
        _OcclusionMap("Occlusion Map", 2D) = "white" {}
        _OcclusionStrength("Occlusion Strength", Range(0, 1)) = 1.0
        
        [ToggleOff] _SpecularOcclusion("Specular Occlusion", Float) = 1.0
        
        // Advanced options
        [Enum(UV0, 0, UV1, 1)] _UVSec("UV Set for secondary textures", Float) = 0
        [Enum(Off, 0, On, 1)] _EnvironmentReflections("Environment Reflections", Int) = 1
        [Enum(Off, 0, On, 1)] _SpecularHighlights("Specular Highlights", Int) = 1
        [Enum(Off, 0, On, 1)] _ReceiveShadows("Receive Shadows", Int) = 1
        
        // Blending options
        [Enum(UnityEngine.Rendering.BlendMode)] _SrcBlend("Src Blend", Int) = 1
        [Enum(UnityEngine.Rendering.BlendMode)] _DstBlend("Dst Blend", Int) = 0
        [Enum(Off, 0, On, 1)] _ZWrite("Z Write", Int) = 1
    }

    SubShader
    {
        Tags 
        { 
            "RenderType" = "Opaque" 
            "RenderPipeline" = "UniversalPipeline"
            "UniversalMaterialType" = "Lit"
            "IgnoreProjector" = "True"
            "ShaderModel" = "4.5"
        }
        
        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode" = "UniversalForward" }

            Blend [_SrcBlend] [_DstBlend]
            ZWrite [_ZWrite]
            ZTest LEqual
            Cull Back

            HLSLPROGRAM
            #pragma target 4.5
            
            // -------------------------------------
            // Material Keywords
            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _ENVIRONMENTREFLECTIONS_OFF
            #pragma shader_feature_local _SPECULAR_SETUP
            #pragma shader_feature_local_fragment _RECEIVE_SHADOWS_OFF

            // -------------------------------------
            // Universal Render Pipeline keywords
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
            #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
            #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
            #pragma multi_compile_fragment _ _SHADOWS_SOFT
            #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION
            
            // -------------------------------------
            // Unity defined keywords
            #pragma multi_compile_fog
            #pragma multi_compile_instancing
            #pragma instancing_options renderinglayer
            
            #pragma vertex LitPassVertex
            #pragma fragment LitPassFragment

            #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.core/ShaderLibrary/UnityGBuffer.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl"

            // To prevent SRP Batcher to break, we need to define the CBUFFER
            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                half4 _BaseColor;
                half _BumpScale;
                half _Metallic;
                half _Smoothness;
                half _SmoothnessTextureChannel;
                half _OcclusionStrength;
                half _SpecularOcclusion;
                half4 _SpecColor;
                half4 _EmissionColor;
            CBUFFER_END

            // Textures
            TEXTURE2D(_BaseMap);           SAMPLER(sampler_BaseMap);
            TEXTURE2D(_BumpMap);           SAMPLER(sampler_BumpMap);
            TEXTURE2D(_EmissionMap);       SAMPLER(sampler_EmissionMap);
            TEXTURE2D(_OcclusionMap);      SAMPLER(sampler_OcclusionMap);

            // Input structure
            struct Attributes
            {
                float4 positionOS   : POSITION;
                float3 normalOS     : NORMAL;
                float4 tangentOS    : TANGENT;
                float2 uv           : TEXCOORD0;
                float2 uv1          : TEXCOORD1;
                float2 uv2          : TEXCOORD2;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            // Varyings structure
            struct Varyings
            {
                float4 positionCS   : SV_POSITION;
                float3 positionWS   : TEXCOORD0;
                float3 normalWS     : TEXCOORD1;
                float4 tangentWS    : TEXCOORD2;
                float2 uv           : TEXCOORD3;
                float2 lightmapUV   : TEXCOORD4;
                half4 fogFactorAndVertexLight : TEXCOORD5;
                
                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                float4 shadowCoord  : TEXCOORD6;
                #endif
                
                #if defined(MAIN_LIGHT_CALCULATE_SHADOWS)
                float4 shadowCoord  : TEXCOORD7;
                #endif
                
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            // Surface data structure
            struct SurfaceData
            {
                half3 albedo;
                half3 specular;
                half metallic;
                half3 emission;
                half smoothness;
                half occlusion;
                half alpha;
                half3 normalTS;
                half3 viewDirWS;
            };

            // Vertex function
            Varyings LitPassVertex(Attributes input)
            {
                Varyings output;
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

                VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
                VertexNormalInputs normalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);
                
                output.positionCS = vertexInput.positionCS;
                output.positionWS = vertexInput.positionWS;
                output.normalWS = normalInput.normalWS;
                output.tangentWS = half4(normalInput.tangentWS, normalInput.sign);
                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                output.lightmapUV = input.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
                
                OUTPUT_LIGHTMAP_UV(input.uv1.xy, unity_LightmapST, output.lightmapUV);
                OUTPUT_SH(output.normalWS.xyz);

                output.fogFactorAndVertexLight = half4(0, 0, 0, 0);
                
                #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
                output.shadowCoord = TransformWorldToShadowCoord(output.positionWS);
                #endif

                return output;
            }

            // Get surface data from input
            SurfaceData InitializeSurfaceData(Varyings input)
            {
                SurfaceData surfaceData;
                
                // Sample base map
                half4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
                surfaceData.albedo = baseMap.rgb * _BaseColor.rgb;
                surfaceData.alpha = baseMap.a * _BaseColor.a;
                
                // Sample normal map
                #ifdef _NORMALMAP
                    half4 normalMap = SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, input.uv);
                    surfaceData.normalTS = UnpackNormalScale(normalMap, _BumpScale);
                #else
                    surfaceData.normalTS = half3(0.0, 0.0, 1.0);
                #endif
                
                // Metallic and smoothness
                surfaceData.metallic = _Metallic;
                surfaceData.smoothness = _Smoothness;
                
                // Specular color
                surfaceData.specular = _SpecColor.rgb;
                
                // Emission
                half4 emissionMap = SAMPLE_TEXTURE2D(_EmissionMap, sampler_EmissionMap, input.uv);
                surfaceData.emission = emissionMap.rgb * _EmissionColor.rgb;
                
                // Occlusion
                half4 occlusionMap = SAMPLE_TEXTURE2D(_OcclusionMap, sampler_OcclusionMap, input.uv);
                surfaceData.occlusion = LerpOneTo(occlusionMap.g, _OcclusionStrength);
                
                // View direction
                surfaceData.viewDirWS = GetWorldSpaceNormalizeViewDir(input.positionWS);
                
                return surfaceData;
            }

            // Fragment function
            half4 LitPassFragment(Varyings input) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

                // Initialize surface data
                SurfaceData surfaceData = InitializeSurfaceData(input);
                
                // Transform normal from tangent space to world space
                half3 normalWS = TransformTangentToWorld(surfaceData.normalTS, 
                    half3x3(input.tangentWS.xyz, 
                    cross(input.normalWS, input.tangentWS.xyz) * input.tangentWS.w, 
                    input.normalWS));
                normalWS = NormalizeNormalPerPixel(normalWS);
                
                // Get main light
                Light mainLight = GetMainLight();
                
                // Calculate lighting
                half3 diffuse = surfaceData.albedo * mainLight.color;
                half3 specular = surfaceData.specular * mainLight.color;
                
                // Apply shadows
                #if defined(_MAIN_LIGHT_SHADOWS) && !defined(_RECEIVE_SHADOWS_OFF)
                    float4 shadowCoord = TransformWorldToShadowCoord(input.positionWS);
                    half shadowAtten = MainLightShadow(shadowCoord);
                    diffuse *= shadowAtten;
                    specular *= shadowAtten;
                #endif
                
                // Calculate final color
                half3 finalColor = diffuse + surfaceData.emission;
                
                // Apply fog
                #ifdef LOREPLACE_fog
                    finalColor = MixFog(finalColor, input.fogFactorAndVertexLight.w);
                #endif
                
                return half4(finalColor, surfaceData.alpha);
            }
            ENDHLSL
        }

        // Shadow Caster Pass
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }

            ZWrite On
            ZTest LEqual
            ColorMask 0

            HLSLPROGRAM
            #pragma target 4.5
            
            #pragma multi_compile_instancing
            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW

            #pragma vertex ShadowPassVertex
            #pragma fragment ShadowPassFragment

            #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/ShadowCaster.hlsl"

            float3 _LightDirection;

            struct Attributes
            {
                float4 positionOS   : POSITION;
                float3 normalOS     : NORMAL;
                float2 uv           : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float2 uv           : TEXCOORD0;
                float4 positionCS   : SV_POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            Varyings ShadowPassVertex(Attributes input)
            {
                Varyings output;
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                
                float3 positionWS = TransformObjectToWorld(input.positionOS.xyz);
                float3 normalWS = TransformObjectToWorldNormal(input.normalOS);

                output.positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, _LightDirection));

                #if UNITY_REVERSED_Z
                    output.positionCS.z = min(output.positionCS.z, output.positionCS.w * UNITY_NEAR_CLIP_VALUE);
                #else
                    output.positionCS.z = max(output.positionCS.z, output.positionCS.w * UNITY_NEAR_CLIP_VALUE);
                #endif

                return output;
            }

            half4 ShadowPassFragment(Varyings input) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
                
                half4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
                clip(baseMap.a * _BaseColor.a - 0.001);
                
                return 0;
            }
            ENDHLSL
        }

        // Depth Only Pass
        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode" = "DepthOnly" }

            ZWrite On
            ColorMask 0

            HLSLPROGRAM
            #pragma target 4.5
            
            #pragma multi_compile_instancing

            #pragma vertex DepthOnlyVertex
            #pragma fragment DepthOnlyFragment

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct Attributes
            {
                float4 positionOS   : POSITION;
                float2 uv           : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float2 uv           : TEXCOORD0;
                float4 positionCS   : SV_POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            Varyings DepthOnlyVertex(Attributes input)
            {
                Varyings output;
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

                output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                return output;
            }

            half4 DepthOnlyFragment(Varyings input) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
                
                half4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
                clip(baseMap.a * _BaseColor.a - 0.001);
                
                return 0;
            }
            ENDHLSL
        }
    }
    
    Fallback "Universal Render Pipeline/Lit"
    CustomEditor "UnityEditor.Rendering.Universal.ShaderGUI.LitShader"
}

Shader "Custom/CustomUnlitShader"
{
    Properties
    {
        [MainTexture] _BaseMap("Base Map", 2D) = "white" {}
        [MainColor] _BaseColor("Base Color", Color) = (1, 1, 1, 1)
        
        _Intensity("Intensity", Range(0, 5)) = 1.0
        _EmissionColor("Emission Color", Color) = (0, 0, 0, 1)
        _EmissionMap("Emission Map", 2D) = "black" {}
        
        [HDR] _TintColor("Tint Color", Color) = (1, 1, 1, 1)
        _Saturation("Saturation", Range(0, 2)) = 1.0
        _Brightness("Brightness", Range(0, 2)) = 1.0
        
        // Blending options
        [Enum(UnityEngine.Rendering.BlendMode)] _SrcBlend("Src Blend", Int) = 1
        [Enum(UnityEngine.Rendering.BlendMode)] _DstBlend("Dst Blend", Int) = 0
        [Enum(Off, 0, On, 1)] _ZWrite("Z Write", Int) = 1
        [Enum(UnityEngine.Rendering.CompareFunction)] _ZTest("Z Test", Int) = 4
        [Enum(UnityEngine.Rendering.CullMode)] _Cull("Cull Mode", Int) = 2
        
        // Advanced options
        [Toggle(_EMISSION)] _UseEmission("Use Emission", Float) = 0
        [Toggle(_TINT_COLOR)] _UseTintColor("Use Tint Color", Float) = 0
    }

    SubShader
    {
        Tags 
        { 
            "RenderType" = "Opaque" 
            "RenderPipeline" = "UniversalPipeline"
            "IgnoreProjector" = "True"
            "ShaderModel" = "4.5"
        }
        
        Pass
        {
            Name "Unlit"
            Tags { "LightMode" = "UniversalForward" }

            Blend [_SrcBlend] [_DstBlend]
            ZWrite [_ZWrite]
            ZTest [_ZTest]
            Cull [_Cull]

            HLSLPROGRAM
            #pragma target 4.5
            
            // Keywords
            #pragma shader_feature_local _EMISSION
            #pragma shader_feature_local _TINT_COLOR
            #pragma multi_compile_fog
            #pragma multi_compile_instancing
            #pragma instancing_options renderinglayer
            
            #pragma vertex UnlitPassVertex
            #pragma fragment UnlitPassFragment

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            // To prevent SRP Batcher to break, we need to define the CBUFFER
            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                half4 _BaseColor;
                half _Intensity;
                half4 _EmissionColor;
                half4 _TintColor;
                half _Saturation;
                half _Brightness;
            CBUFFER_END

            // Textures
            TEXTURE2D(_BaseMap);           SAMPLER(sampler_BaseMap);
            TEXTURE2D(_EmissionMap);       SAMPLER(sampler_EmissionMap);

            // Input structure
            struct Attributes
            {
                float4 positionOS   : POSITION;
                float2 uv           : TEXCOORD0;
                float2 uv1          : TEXCOORD1;
                float2 uv2          : TEXCOORD2;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            // Varyings structure
            struct Varyings
            {
                float4 positionCS   : SV_POSITION;
                float2 uv           : TEXCOORD0;
                float2 lightmapUV   : TEXCOORD1;
                half4 fogFactor     : TEXCOORD2;
                
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            // Vertex function
            Varyings UnlitPassVertex(Attributes input)
            {
                Varyings output;
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

                VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
                
                output.positionCS = vertexInput.positionCS;
                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                output.lightmapUV = input.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
                
                OUTPUT_LIGHTMAP_UV(input.uv1.xy, unity_LightmapST, output.lightmapUV);
                
                #ifdef LOREPLACE_fog
                    output.fogFactor = half4(0, 0, 0, 0);
                    output.fogFactor.w = ComputeFogFactor(vertexInput.positionCS.z);
                #endif

                return output;
            }

            // Convert RGB to HSV
            float3 RGBToHSV(float3 rgb)
            {
                float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
                float4 p = lerp(float4(rgb.bg, K.wz), float4(rgb.gb, K.xy), step(rgb.b, rgb.g));
                float4 q = lerp(float4(p.xyw, rgb.r), float4(rgb.r, p.yzx), step(p.x, rgb.r));
                
                float d = q.x - min(q.w, q.y);
                float e = 1.0e-10;
                return float3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
            }

            // Convert HSV to RGB
            float3 HSVToRGB(float3 hsv)
            {
                float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
                float3 p = abs(frac(hsv.xxx + K.xyz) * 6.0 - K.www);
                return hsv.z * lerp(K.xxx, saturate(p - K.xxx), hsv.y);
            }

            // Apply color adjustments
            half3 ApplyColorAdjustments(half3 color)
            {
                // Apply brightness
                color *= _Brightness;
                
                // Apply saturation
                half3 gray = half3(dot(color, half3(0.299, 0.587, 0.114)));
                color = lerp(gray, color, _Saturation);
                
                // Apply tint color if enabled
                #ifdef _TINT_COLOR
                    color *= _TintColor.rgb;
                #endif
                
                return saturate(color);
            }

            // Fragment function
            half4 UnlitPassFragment(Varyings input) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

                // Sample base texture
                half4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
                
                // Apply base color
                half3 color = baseMap.rgb * _BaseColor.rgb;
                
                // Apply intensity
                color *= _Intensity;
                
                // Add emission if enabled
                #ifdef _EMISSION
                    half4 emissionMap = SAMPLE_TEXTURE2D(_EmissionMap, sampler_EmissionMap, input.uv);
                    half3 emission = emissionMap.rgb * _EmissionColor.rgb;
                    color += emission;
                #endif
                
                // Apply color adjustments
                color = ApplyColorAdjustments(color);
                
                // Apply alpha from base map
                half alpha = baseMap.a * _BaseColor.a;
                
                // Apply fog if enabled
                #ifdef LOREPLACE_fog
                    color = MixFog(color, input.fogFactor.w);
                #endif
                
                return half4(color, alpha);
            }
            ENDHLSL
        }
    }
    
    Fallback "Universal Render Pipeline/Unlit"
    CustomEditor "UnityEditor.Rendering.Universal.ShaderGUI.UnlitShader"
}

Shader "Custom/InstancedLitShader"
{
    Properties
    {
        [MainTexture] _BaseMap("Base Map", 2D) = "white" {}
        [MainColor] _BaseColor("Base Color", Color) = (1, 1, 1, 1)
        
        _BumpMap("Normal Map", 2D) = "bump" {}
        _BumpScale("Normal Scale", Range(0, 2)) = 1.0
        
        _Metallic("Metallic", Range(0, 1)) = 0.0
        _Smoothness("Smoothness", Range(0, 1)) = 0.5
        
        // Instance-specific properties
        _InstanceColor("Instance Color", Color) = (1, 1, 1, 1)
        _InstanceScale("Instance Scale", Vector) = (1, 1, 1, 1)
        _InstanceRotation("Instance Rotation", Vector) = (0, 0, 0, 1)
    }

    SubShader
    {
        Tags 
        { 
            "RenderType" = "Opaque" 
            "RenderPipeline" = "UniversalPipeline"
            "UniversalMaterialType" = "Lit"
            "IgnoreProjector" = "True"
            "ShaderModel" = "4.5"
        }
        
        Pass
        {
            Name "ForwardLit"
            Tags { "LightMode" = "UniversalForward" }

            HLSLPROGRAM
            #pragma target 4.5
            
            // Material Keywords
            #pragma shader_feature_local _NORMALMAP
            #pragma shader_feature_local _SPECULARHIGHLIGHTS_OFF
            #pragma shader_feature_local _ENVIRONMENTREFLECTIONS_OFF
            #pragma shader_feature_local _SPECULAR_SETUP
            #pragma shader_feature_local_fragment _RECEIVE_SHADOWS_OFF

            // Universal Render Pipeline keywords
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
            #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
            #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
            #pragma multi_compile_fragment _ _SHADOWS_SOFT
            
            // Unity defined keywords
            #pragma multi_compile_fog
            #pragma multi_compile_instancing
            #pragma instancing_options renderinglayer
            
            #pragma vertex LitPassVertex
            #pragma fragment LitPassFragment

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

            // Instance-specific CBUFFER
            UNITY_INSTANCING_BUFFER_START(PerInstance)
                UNITY_DEFINE_INSTANCED_PROP(float4, _InstanceColor)
                UNITY_DEFINE_INSTANCED_PROP(float3, _InstanceScale)
                UNITY_DEFINE_INSTANCED_PROP(float4, _InstanceRotation)
            UNITY_INSTANCING_BUFFER_END(PerInstance)

            // Material CBUFFER
            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
                half4 _BaseColor;
                half _BumpScale;
                half _Metallic;
                half _Smoothness;
            CBUFFER_END

            // Textures
            TEXTURE2D(_BaseMap);           SAMPLER(sampler_BaseMap);
            TEXTURE2D(_BumpMap);           SAMPLER(sampler_BumpMap);

            // Input structure
            struct Attributes
            {
                float4 positionOS   : POSITION;
                float3 normalOS     : NORMAL;
                float4 tangentOS    : TANGENT;
                float2 uv           : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            // Varyings structure
            struct Varyings
            {
                float4 positionCS   : SV_POSITION;
                float3 positionWS   : TEXCOORD0;
                float3 normalWS     : TEXCOORD1;
                float4 tangentWS    : TEXCOORD2;
                float2 uv           : TEXCOORD3;
                float4 shadowCoord  : TEXCOORD4;
                
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            // Apply instance transformations
            float3 ApplyInstanceTransform(float3 positionOS, uint instanceID)
            {
                // Get instance properties
                float4 instanceColor = UNITY_ACCESS_INSTANCED_PROP(PerInstance, _InstanceColor);
                float3 instanceScale = UNITY_ACCESS_INSTANCED_PROP(PerInstance, _InstanceScale);
                float4 instanceRotation = UNITY_ACCESS_INSTANCED_PROP(PerInstance, _InstanceRotation);
                
                // Apply scale
                positionOS *= instanceScale;
                
                // Apply rotation (simplified - using quaternion to matrix conversion would be more accurate)
                float3 rotation = instanceRotation.xyz;
                float3 rotatedPos = positionOS;
                
                // Apply rotation around each axis
                float cosX = cos(rotation.x);
                float sinX = sin(rotation.x);
                rotatedPos.yz = float2(
                    rotatedPos.y * cosX - rotatedPos.z * sinX,
                    rotatedPos.y * sinX + rotatedPos.z * cosX
                );
                
                float cosY = cos(rotation.y);
                float sinY = sin(rotation.y);
                rotatedPos.xz = float2(
                    rotatedPos.x * cosY + rotatedPos.z * sinY,
                    -rotatedPos.x * sinY + rotatedPos.z * cosY
                );
                
                float cosZ = cos(rotation.z);
                float sinZ = sin(rotation.z);
                rotatedPos.xy = float2(
                    rotatedPos.x * cosZ - rotatedPos.y * sinZ,
                    rotatedPos.x * sinZ + rotatedPos.y * cosZ
                );
                
                return rotatedPos;
            }

            // Vertex function
            Varyings LitPassVertex(Attributes input)
            {
                Varyings output;
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

                // Apply instance transformations
                float3 positionOS = ApplyInstanceTransform(input.positionOS.xyz, input.instanceID);
                
                VertexPositionInputs vertexInput = GetVertexPositionInputs(positionOS);
                VertexNormalInputs normalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);
                
                output.positionCS = vertexInput.positionCS;
                output.positionWS = vertexInput.positionWS;
                output.normalWS = normalInput.normalWS;
                output.tangentWS = half4(normalInput.tangentWS, normalInput.sign);
                output.uv = TRANSFORM_TEX(input.uv, _BaseMap);
                
                #if defined(_MAIN_LIGHT_SHADOWS)
                    output.shadowCoord = TransformWorldToShadowCoord(output.positionWS);
                #endif

                return output;
            }

            // Fragment function
            half4 LitPassFragment(Varyings input) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

                // Sample base map
                half4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
                
                // Get instance color
                half4 instanceColor = UNITY_ACCESS_INSTANCED_PROP(PerInstance, _InstanceColor);
                
                // Combine base color with instance color
                half3 color = baseMap.rgb * _BaseColor.rgb * instanceColor.rgb;
                
                // Sample and apply normal map if enabled
                #ifdef _NORMALMAP
                    half4 normalMap = SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, input.uv);
                    half3 normalTS = UnpackNormalScale(normalMap, _BumpScale);
                    
                    // Transform normal from tangent space to world space
                    half3 normalWS = TransformTangentToWorld(normalTS, 
                        half3x3(input.tangentWS.xyz, 
                        cross(input.normalWS, input.tangentWS.xyz) * input.tangentWS.w, 
                        input.normalWS));
                    normalWS = NormalizeNormalPerPixel(normalWS);
                #else
                    half3 normalWS = input.normalWS;
                #endif
                
                // Get main light
                Light mainLight = GetMainLight();
                
                // Simple lighting calculation
                half NdotL = saturate(dot(normalWS, mainLight.direction));
                half3 lighting = mainLight.color * NdotL;
                
                // Apply lighting
                color *= (lighting + 0.2); // Add ambient
                
                // Apply shadows if enabled
                #if defined(_MAIN_LIGHT_SHADOWS) && !defined(_RECEIVE_SHADOWS_OFF)
                    half shadowAtten = MainLightShadow(input.shadowCoord);
                    color *= shadowAtten;
                #endif
                
                // Apply alpha
                half alpha = baseMap.a * _BaseColor.a * instanceColor.a;
                
                return half4(color, alpha);
            }
            ENDHLSL
        }

        // Shadow Caster Pass with instancing
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }

            ZWrite On
            ZTest LEqual
            ColorMask 0

            HLSLPROGRAM
            #pragma target 4.5
            
            #pragma multi_compile_instancing
            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW

            #pragma vertex ShadowPassVertex
            #pragma fragment ShadowPassFragment

            #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/ShadowCaster.hlsl"

            float3 _LightDirection;

            // Instance-specific CBUFFER for shadow pass
            UNITY_INSTANCING_BUFFER_START(PerInstanceShadow)
                UNITY_DEFINE_INSTANCED_PROP(float3, _InstanceScale)
            UNITY_INSTANCING_BUFFER_END(PerInstanceShadow)

            struct Attributes
            {
                float4 positionOS   : POSITION;
                float3 normalOS     : NORMAL;
                float2 uv           : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float2 uv           : TEXCOORD0;
                float4 positionCS   : SV_POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            Varyings ShadowPassVertex(Attributes input)
            {
                Varyings output;
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

                // Apply instance scale to position
                float3 instanceScale = UNITY_ACCESS_INSTANCED_PROP(PerInstanceShadow, _InstanceScale);
                float3 scaledPosition = input.positionOS.xyz * instanceScale;
                
                float3 positionWS = TransformObjectToWorld(scaledPosition);
                float3 normalWS = TransformObjectToWorldNormal(input.normalOS);

                output.positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, _LightDirection));

                #if UNITY_REVERSED_Z
                    output.positionCS.z = min(output.positionCS.z, output.positionCS.w * UNITY_NEAR_CLIP_VALUE);
                #else
                    output.positionCS.z = max(output.positionCS.z, output.positionCS.w * UNITY_NEAR_CLIP_VALUE);
                #endif

                return output;
            }

            half4 ShadowPassFragment(Varyings input) : SV_Target
            {
                return 0;
            }
            ENDHLSL
        }
    }
    
    Fallback "Universal Render Pipeline/Lit"
}