Pass { Tags{"LightMode" = "LightweightForward"} ${Tags} ${Blending} ${Culling} ${ZTest} ${ZWrite} HLSLPROGRAM // Required to compile gles 2.0 with standard srp library #pragma prefer_hlslcc gles #pragma target 3.0 // ------------------------------------- // Lightweight Pipeline keywords // We have no good approach exposed to skip shader variants, e.g, ideally we would like to skip _CASCADE for all puctual lights // Lightweight combines light classification and shadows keywords to reduce shader variants. // Lightweight shader library declares defines based on these keywords to avoid having to check them in the shaders // Core.hlsl defines _MAIN_LIGHT_DIRECTIONAL and _MAIN_LIGHT_SPOT (point lights can't be main light) // Shadow.hlsl defines _SHADOWS_ENABLED, _SHADOWS_SOFT, _SHADOWS_CASCADE, _SHADOWS_PERSPECTIVE #pragma multi_compile _ _MAIN_LIGHT_DIRECTIONAL_SHADOW _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE _MAIN_LIGHT_DIRECTIONAL_SHADOW_SOFT _MAIN_LIGHT_DIRECTIONAL_SHADOW_CASCADE_SOFT _MAIN_LIGHT_SPOT_SHADOW _MAIN_LIGHT_SPOT_SHADOW_SOFT #pragma multi_compile _ _MAIN_LIGHT_COOKIE #pragma multi_compile _ _ADDITIONAL_LIGHTS #pragma multi_compile _ _VERTEX_LIGHTS #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE #pragma multi_compile _ FOG_LINEAR FOG_EXP2 // ------------------------------------- // Unity defined keywords #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON #pragma multi_compile _ DIRLIGHTMAP_COMBINED LIGHTMAP_ON //-------------------------------------- // GPU Instancing #pragma multi_compile_instancing // LW doesn't support dynamic GI. So we save 30% shader variants if we assume // LIGHTMAP_ON when DIRLIGHTMAP_COMBINED is set #ifdef DIRLIGHTMAP_COMBINED #define LIGHTMAP_ON #endif #pragma vertex vert #pragma fragment frag ${Defines} #include "LWRP/ShaderLibrary/Core.hlsl" #include "LWRP/ShaderLibrary/Lighting.hlsl" #include "CoreRP/ShaderLibrary/Color.hlsl" #include "CoreRP/ShaderLibrary/UnityInstancing.hlsl" #include "ShaderGraphLibrary/Functions.hlsl" ${Graph} struct GraphVertexOutput { float4 clipPos : SV_POSITION; float4 lightmapUVOrVertexSH : TEXCOORD0; half4 fogFactorAndVertexLight : TEXCOORD1; // x: fogFactor, yzw: vertex light float4 shadowCoord : TEXCOORD2; ${Interpolators} UNITY_VERTEX_INPUT_INSTANCE_ID }; GraphVertexOutput vert (GraphVertexInput v) { v = PopulateVertexData(v); GraphVertexOutput o = (GraphVertexOutput)0; UNITY_SETUP_INSTANCE_ID(v); UNITY_TRANSFER_INSTANCE_ID(v, o); ${VertexShader} float3 lwWNormal = TransformObjectToWorldNormal(v.normal); float3 lwWorldPos = TransformObjectToWorld(v.vertex.xyz); float4 clipPos = TransformWorldToHClip(lwWorldPos); // We either sample GI from lightmap or SH. lightmap UV and vertex SH coefficients // are packed in lightmapUVOrVertexSH to save interpolator. // The following funcions initialize OUTPUT_LIGHTMAP_UV(v.texcoord1, unity_LightmapST, o.lightmapUVOrVertexSH); OUTPUT_SH(lwWNormal, o.lightmapUVOrVertexSH); half3 vertexLight = VertexLighting(lwWorldPos, lwWNormal); half fogFactor = ComputeFogFactor(clipPos.z); o.fogFactorAndVertexLight = half4(fogFactor, vertexLight); o.clipPos = clipPos; #if defined(_SHADOWS_ENABLED) && !defined(_SHADOWS_CASCADE) o.shadowCoord = ComputeShadowCoord(lwWorldPos); #else o.shadowCoord = float4(0, 0, 0, 0); #endif return o; } half4 frag (GraphVertexOutput IN) : SV_Target { UNITY_SETUP_INSTANCE_ID(IN); ${LocalPixelShader} SurfaceInputs surfaceInput = (SurfaceInputs)0; ${SurfaceInputs} SurfaceDescription surf = PopulateSurfaceData(surfaceInput); float3 Albedo = float3(0.5, 0.5, 0.5); float3 Specular = float3(0, 0, 0); float Metallic = 1; float3 Normal = float3(0, 0, 1); float3 Emission = 0; float Smoothness = 0.5; float Occlusion = 1; float Alpha = 1; float AlphaClipThreshold = 0; ${SurfaceOutputRemap} InputData inputData; inputData.positionWS = WorldSpacePosition; #ifdef _NORMALMAP inputData.normalWS = TangentToWorldNormal(Normal, WorldSpaceTangent, WorldSpaceBiTangent, WorldSpaceNormal); #else inputData.normalWS = normalize(WorldSpaceNormal); #endif #ifdef SHADER_API_MOBILE // viewDirection should be normalized here, but we avoid doing it as it's close enough and we save some ALU. inputData.viewDirectionWS = WorldSpaceViewDirection; #else inputData.viewDirectionWS = normalize(WorldSpaceViewDirection); #endif #ifdef _SHADOWS_ENABLED inputData.shadowCoord = IN.shadowCoord; #else inputData.shadowCoord = float4(0, 0, 0, 0); #endif inputData.fogCoord = IN.fogFactorAndVertexLight.x; inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw; inputData.bakedGI = SampleGI(IN.lightmapUVOrVertexSH, inputData.normalWS); half4 color = LightweightFragmentPBR( inputData, Albedo, Metallic, Specular, Smoothness, Occlusion, Emission, Alpha); // Computes fog factor per-vertex ApplyFog(color.rgb, IN.fogFactorAndVertexLight.x); #if _AlphaClip clip(Alpha - AlphaClipThreshold); #endif return color; } ENDHLSL }