Reduced number of shader variations.

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetInspector.cs

             public static GUIContent renderingLabel = new GUIContent("Rendering");
             public static GUIContent shadowLabel = new GUIContent("Shadows");
             public static GUIContent defaults = new GUIContent("Defaults");
-            public static GUIContent linearRenderingLabel = new GUIContent("Force Linear Colorspace", "When enabled Lightweight shader will perform gamma to linear conversion in the shader when linear rendering is not supported or disabled");
 
             public static GUIContent renderScaleLabel = new GUIContent("Render Scale", "Allows game to render at a resolution different than native resolution. UI is always rendered at native resolution.");
 
         }
 
         private int kMaxSupportedAdditionalPixelLights = 8;
-        private SerializedProperty m_LinearRenderingProperty;
         private SerializedProperty m_RenderScale;
         private SerializedProperty m_MaxAdditionalPixelLights;
         private SerializedProperty m_SupportsVertexLightProp;
 
         void OnEnable()
         {
-            m_LinearRenderingProperty = serializedObject.FindProperty("m_LinearRendering");
             m_RenderScale = serializedObject.FindProperty("m_RenderScale");
             m_MaxAdditionalPixelLights = serializedObject.FindProperty("m_MaxAdditionalPixelLights");
             m_SupportsVertexLightProp = serializedObject.FindProperty("m_SupportsVertexLight");
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(Styles.renderingLabel, EditorStyles.boldLabel);
             EditorGUI.indentLevel++;
-            EditorGUILayout.PropertyField(m_LinearRenderingProperty, Styles.linearRenderingLabel);
             EditorGUILayout.BeginHorizontal();
             EditorGUILayout.LabelField(Styles.renderScaleLabel);
             m_RenderScale.floatValue = EditorGUILayout.Slider(m_RenderScale.floatValue, 0.1f, 1.0f);

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

         private void InitializeLightConstants(VisibleLight[] lights, int lightIndex, out Vector4 lightPos, out Vector4 lightColor, out Vector4 lightSpotDir,
             out Vector4 lightAttenuationParams)
         {
-            lightPos = Vector4.zero;
+            lightPos = new Vector4(0.0f, 0.0f, 1.0f, 0.0f);
-            // When no lights are available in the pipeline or maxPixelLights is set to 0
-            // In this case we want to initialize the lightData to default values and return
+            // When no lights are visible, main light will be set to -1.
+            // In this case we initialize it to default values and return
             if (lightIndex < 0)
                 return;
 
         {
             // Main light has an optimized shader path for main light. This will benefit games that only care about a single light.
             // Lightweight pipeline also supports only a single shadow light, if available it will be the main light.
-            if (lightData.mainLightIndex != -1)
-            {
-                SetupMainLightConstants (cmd, lights, lightData.mainLightIndex, ref context);
-                if (lightData.shadowsRendered)
-                    SetupShadowShaderConstants (cmd, ref context, ref lights[lightData.mainLightIndex], m_ShadowCasterCascadesCount);
-            }
+            SetupMainLightConstants(cmd, lights, lightData.mainLightIndex, ref context);
+            if (lightData.shadowsRendered)
+                SetupShadowShaderConstants(cmd, ref context, ref lights[lightData.mainLightIndex], m_ShadowCasterCascadesCount);
 
             if (lightData.totalAdditionalLightsCount > 0)
                 SetupAdditionalListConstants(cmd, lights, ref lightData, ref context);
         private void SetShaderKeywords(CommandBuffer cmd, ref LightData lightData, VisibleLight[] visibleLights)
         {
             int vertexLightsCount = lightData.totalAdditionalLightsCount - lightData.pixelAdditionalLightsCount;
-            LightweightUtils.SetKeyword(cmd, "_LIGHTWEIGHT_FORCE_LINEAR", m_Asset.ForceLinearRendering);
-            LightweightUtils.SetKeyword (cmd, "_MAIN_DIRECTIONAL_LIGHT", mainLightIndex != -1 && visibleLights[mainLightIndex].lightType == LightType.Directional);
+            LightweightUtils.SetKeyword (cmd, "_MAIN_DIRECTIONAL_LIGHT", mainLightIndex == -1 || visibleLights[mainLightIndex].lightType == LightType.Directional);
             LightweightUtils.SetKeyword (cmd, "_MAIN_SPOT_LIGHT", mainLightIndex != -1 && visibleLights[mainLightIndex].lightType == LightType.Spot);
             LightweightUtils.SetKeyword (cmd, "_MAIN_POINT_LIGHT", mainLightIndex != -1 && visibleLights[mainLightIndex].lightType == LightType.Point);
             LightweightUtils.SetKeyword(cmd, "_ADDITIONAL_LIGHTS", lightData.totalAdditionalLightsCount > 0);

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_ShadowCascades: 1
   m_Cascade2Split: 0.25
   m_Cascade4Split: {x: 0.067, y: 0.2, z: 0.467}
-  m_LinearRendering: 1
   m_AttenuationTexture: {fileID: 2800000, guid: ee420ad43ff580149a07f10ad66c49ff,
     type: 3}
   m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d,

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.cs

         [SerializeField] private ShadowCascades m_ShadowCascades = ShadowCascades.NO_CASCADES;
         [SerializeField] private float m_Cascade2Split = 0.25f;
         [SerializeField] private Vector3 m_Cascade4Split = new Vector3(0.067f, 0.2f, 0.467f);
-        [SerializeField] private bool m_LinearRendering = true;
         [SerializeField] private Texture2D m_AttenuationTexture;
 
         [SerializeField] private Material m_DefaultDiffuseMaterial;
         {
             get { return m_Cascade4Split; }
             private set { m_Cascade4Split = value; }
-        }
-
-        public bool ForceLinearRendering
-        {
-            get { return m_LinearRendering; }
-            set { m_LinearRendering = value; }
         }
 
         public Texture2D AttenuationTexture

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightCore.cginc

 
 #define MAX_VISIBLE_LIGHTS 16
 
-#if defined(UNITY_COLORSPACE_GAMMA) && defined(_LIGHTWEIGHT_FORCE_LINEAR)
+#if defined(UNITY_COLORSPACE_GAMMA)
     #define LIGHTWEIGHT_GAMMA_TO_LINEAR(gammaColor) gammaColor * gammaColor
     #define LIGHTWEIGHT_LINEAR_TO_GAMMA(linColor) sqrt(color)
 #else

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightLighting.cginc

     light.atten = _AdditionalLightAttenuationParams[lightIndex]; \
     light.spotDir = _AdditionalLightSpotDir[lightIndex]
 
-#if (defined(_MAIN_DIRECTIONAL_LIGHT) || defined(_MAIN_SPOT_LIGHT) || defined(_MAIN_POINT_LIGHT))
-#define _MAIN_LIGHT
-#endif
-
 struct LightInput
 {
     float4 pos;
     half3 color = LightweightBRDFIndirect(brdfData, indirectLight, roughness2, fresnelTerm);
     half3 lightDirectionWS;
 
-#ifdef _MAIN_LIGHT
     LightInput light;
     INITIALIZE_MAIN_LIGHT(light);
     half lightAtten = ComputeMainLightAttenuation(light, normalWS, positionWS, lightDirectionWS);
     half3 radiance = light.color * (lightAtten * NdotL);
     color += LightweightBDRF(brdfData, roughness2, normalWS, lightDirectionWS, viewDirectionWS) * radiance;
-#endif
 
 #ifdef _ADDITIONAL_LIGHTS
     int pixelLightCount = min(_AdditionalLightCount.x, unity_LightIndicesOffsetAndCount.y);

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPassLit.cginc

     half3 color = (SHEvalLinearL0L1(half4(normalWorld, 1.0)) + IN.ambientOrLightmapUV.xyz) * diffuse;
 #endif
 
-#ifdef _MAIN_LIGHT
     LightInput lightInput;
     INITIALIZE_MAIN_LIGHT(lightInput);
     half lightAtten = ComputeMainLightAttenuation(lightInput, normalWorld, worldPos, lightDirection);
     color += LightingBlinnPhong(diffuse, specularGloss, lightDirection, normalWorld, viewDir, lightAtten) * lightInput.color;
 #else
     color += LightingLambert(diffuse, lightDirection, normalWorld, lightAtten) * lightInput.color;
-#endif
-
 #endif
 
 #ifdef _ADDITIONAL_LIGHTS

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandard.shader

             #pragma shader_feature _GLOSSYREFLECTIONS_OFF
             #pragma shader_feature _OCCLUSIONMAP
 
-            #pragma multi_compile _ _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
+            #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
-            #pragma multi_compile _ _LIGHTWEIGHT_FORCE_LINEAR
             #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ _HARD_SHADOWS _SOFT_SHADOWS _HARD_SHADOWS_CASCADES _SOFT_SHADOWS_CASCADES

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardSimpleLighting.shader

             #pragma shader_feature _NORMALMAP
             #pragma shader_feature _EMISSION
 
-            #pragma multi_compile _ _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
+            #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
-            #pragma multi_compile _ _LIGHTWEIGHT_FORCE_LINEAR
             #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ _HARD_SHADOWS _SOFT_SHADOWS _HARD_SHADOWS_CASCADES _SOFT_SHADOWS_CASCADES