Removed unused light cookied code. (#1917)

com.unity.render-pipelines.lightweight/LWRP/Editor/LightweightRenderPipelineLightEditor.cs

         {
             public readonly GUIContent SpotAngle = EditorGUIUtility.TrTextContent("Spot Angle", "Controls the angle in degrees at the base of a Spot light's cone.");
 
-            public readonly GUIContent Cookie = EditorGUIUtility.TrTextContent("Cookie", "Specifies the Texture mask to cast shadows, create silhouettes, or patterned illumination for the light.");
-            public readonly GUIContent CookieSize = EditorGUIUtility.TrTextContent("Cookie Size", "Controls the size of the cookie mask currently assigned to the light.");
-
-            public readonly GUIContent CookieWarning = EditorGUIUtility.TrTextContent("Cookie textures for spot lights should be set to clamp, not repeat, to avoid artifacts.");
             public readonly GUIContent DisabledLightWarning = EditorGUIUtility.TrTextContent("Lighting has been disabled in at least one Scene view. Any changes applied to lights in the Scene will not be updated in these views until Lighting has been enabled again.");
 
             public readonly GUIContent ShadowsNotSupportedWarning = EditorGUIUtility.TrTextContent("Realtime shadows for point lights are not supported. Either disable shadows or set the light mode to Baked.");
 
         public bool bakingWarningValue { get { return !UnityEditor.Lightmapping.bakedGI && lightmappingTypeIsSame && settings.isBakedOrMixed; } }
         public bool showLightBounceIntensity { get { return true; } }
-        public bool cookieWarningValue
-        {
-            get
-            {
-                return typeIsSame && lightProperty.type == LightType.Spot &&
-                    !settings.cookieProp.hasMultipleDifferentValues && settings.cookie && settings.cookie.wrapMode != TextureWrapMode.Clamp;
-            }
-        }
 
         public bool isShadowEnabled { get { return settings.shadowsType.intValue != 0; } }
 
 
             ShadowsGUI();
 
-            /* Tim: Disable cookie for v1 to save on shader combinations
-            using (var group = new EditorGUILayout.FadeGroupScope(animShowRuntimeOptions.faded))
-                if (group.visible)
-                    DrawCookie();
-
-            // Cookie size also requires directional light
-            using (var group = new EditorGUILayout.FadeGroupScope(animShowRuntimeOptions.faded * animShowDirOptions.faded))
-                if (group.visible)
-                    DrawCookieSize();
-           */
-
             settings.DrawRenderMode();
             settings.DrawCullingMask();
 
         void DrawSpotAngle()
         {
             EditorGUILayout.Slider(settings.spotAngle, 1f, 179f, s_Styles.SpotAngle);
-        }
-
-        void DrawCookie()
-        {
-            EditorGUILayout.PropertyField(settings.cookieProp, s_Styles.Cookie);
-
-            if (cookieWarningValue)
-            {
-                // warn on spotlights if the cookie is set to repeat
-                EditorGUILayout.HelpBox(s_Styles.CookieWarning.text, MessageType.Warning);
-            }
-        }
-
-        void DrawCookieSize()
-        {
-            EditorGUILayout.PropertyField(settings.cookieSize, s_Styles.CookieSize);
         }
 
         void ShadowsGUI()

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderPreprocessor.cs

         public static readonly ShaderKeyword AdditionalLights = new ShaderKeyword(LightweightKeywordStrings.AdditionalLights);
         public static readonly ShaderKeyword VertexLights = new ShaderKeyword(LightweightKeywordStrings.VertexLights);
         public static readonly ShaderKeyword MixedLightingSubtractive = new ShaderKeyword(LightweightKeywordStrings.MixedLightingSubtractive);
-        public static readonly ShaderKeyword MainLightCookie = new ShaderKeyword(LightweightKeywordStrings.MainLightCookie);
         public static readonly ShaderKeyword DirectionalShadows = new ShaderKeyword(LightweightKeywordStrings.DirectionalShadows);
         public static readonly ShaderKeyword LocalShadows = new ShaderKeyword(LightweightKeywordStrings.LocalShadows);
         public static readonly ShaderKeyword SoftShadows = new ShaderKeyword(LightweightKeywordStrings.SoftShadows);

com.unity.render-pipelines.lightweight/LWRP/LightweightPipelineCore.cs

         public static readonly string AdditionalLights = "_ADDITIONAL_LIGHTS";
         public static readonly string VertexLights = "_VERTEX_LIGHTS";
         public static readonly string MixedLightingSubtractive = "_MIXED_LIGHTING_SUBTRACTIVE";
-        public static readonly string MainLightCookie = "_MAIN_LIGHT_COOKIE";
         public static readonly string DirectionalShadows = "_SHADOWS_ENABLED";
         public static readonly string LocalShadows = "_LOCAL_SHADOWS_ENABLED";
         public static readonly string SoftShadows = "_SHADOWS_SOFT";
                     s_PipelineCapabilities |= PipelineCapabilities.SoftShadows;
             }
         }
-
-        public static void GetLightCookieMatrix(VisibleLight light, out Matrix4x4 cookieMatrix)
-        {
-            cookieMatrix = Matrix4x4.Inverse(light.localToWorld);
-
-            if (light.lightType == LightType.Directional)
-            {
-                float scale = 1.0f / light.light.cookieSize;
-
-                // apply cookie scale and offset by 0.5 to convert from [-0.5, 0.5] to texture space [0, 1]
-                Vector4 row0 = cookieMatrix.GetRow(0);
-                Vector4 row1 = cookieMatrix.GetRow(1);
-                cookieMatrix.SetRow(0, new Vector4(row0.x * scale, row0.y * scale, row0.z * scale, row0.w * scale + 0.5f));
-                cookieMatrix.SetRow(1, new Vector4(row1.x * scale, row1.y * scale, row1.z * scale, row1.w * scale + 0.5f));
-            }
-            else if (light.lightType == LightType.Spot)
-            {
-                // we want out.w = 2.0 * in.z / m_CotanHalfSpotAngle
-                // c = cotHalfSpotAngle
-                // 1 0 0 0
-                // 0 1 0 0
-                // 0 0 1 0
-                // 0 0 2/c 0
-                // the "2" will be used to scale .xy for the cookie as in .xy/2 + 0.5
-                float scale = 1.0f / light.range;
-                float halfSpotAngleRad = Mathf.Deg2Rad * light.spotAngle * 0.5f;
-                float cs = Mathf.Cos(halfSpotAngleRad);
-                float ss = Mathf.Sin(halfSpotAngleRad);
-                float cotHalfSpotAngle = cs / ss;
-
-                Matrix4x4 scaleMatrix = Matrix4x4.identity;
-                scaleMatrix.m00 = scaleMatrix.m11 = scaleMatrix.m22 = scale;
-                scaleMatrix.m33 = 0.0f;
-                scaleMatrix.m32 = scale * (2.0f / cotHalfSpotAngle);
-
-                cookieMatrix = scaleMatrix * cookieMatrix;
-            }
-
-            // Remaining light types don't support cookies
-        }
-
-        public static bool IsSupportedCookieType(LightType lightType)
-        {
-            return lightType == LightType.Directional || lightType == LightType.Spot;
-        }
-
         public static bool IsStereoEnabled(Camera camera)
         {
             bool isSceneViewCamera = camera.cameraType == CameraType.SceneView;

com.unity.render-pipelines.lightweight/LWRP/Passes/SetupLightweightConstanstPass.cs

         {
             public static int _MainLightPosition;
             public static int _MainLightColor;
-            public static int _MainLightCookie;
-            public static int _WorldToLight;
 
             public static int _AdditionalLightCount;
             public static int _AdditionalLightPosition;
         {
             LightConstantBuffer._MainLightPosition = Shader.PropertyToID("_MainLightPosition");
             LightConstantBuffer._MainLightColor = Shader.PropertyToID("_MainLightColor");
-            LightConstantBuffer._MainLightCookie = Shader.PropertyToID("_MainLightCookie");
-            LightConstantBuffer._WorldToLight = Shader.PropertyToID("_WorldToLight");
             LightConstantBuffer._AdditionalLightCount = Shader.PropertyToID("_AdditionalLightCount");
             LightConstantBuffer._AdditionalLightPosition = Shader.PropertyToID("_AdditionalLightPosition");
             LightConstantBuffer._AdditionalLightColor = Shader.PropertyToID("_AdditionalLightColor");
         void SetupMainLightConstants(CommandBuffer cmd, ref LightData lightData)
         {
             Vector4 lightPos, lightColor, lightAttenuation, lightSpotDir;
-            List<VisibleLight> lights = lightData.visibleLights;
-
-            if (lightData.mainLightIndex >= 0)
-            {
-                VisibleLight mainLight = lights[lightData.mainLightIndex];
-                Light mainLightRef = mainLight.light;
-
-                if (LightweightPipeline.IsSupportedCookieType(mainLight.lightType) && mainLightRef.cookie != null)
-                {
-                    Matrix4x4 lightCookieMatrix;
-                    LightweightPipeline.GetLightCookieMatrix(mainLight, out lightCookieMatrix);
-                    cmd.SetGlobalTexture(LightConstantBuffer._MainLightCookie, mainLightRef.cookie);
-                    cmd.SetGlobalMatrix(LightConstantBuffer._WorldToLight, lightCookieMatrix);
-                }
-            }
 
             cmd.SetGlobalVector(LightConstantBuffer._MainLightPosition, lightPos);
             cmd.SetGlobalVector(LightConstantBuffer._MainLightColor, lightColor);
             CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.AdditionalLights, lightData.totalAdditionalLightsCount > 0);
             CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.MixedLightingSubtractive, m_MixedLightingSetup == MixedLightingSetup.Subtractive);
             CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.VertexLights, vertexLightsCount > 0);
-
-            // TODO: We have to discuss cookie approach on LWRP.
-            // CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.MainLightCookieText, mainLightIndex != -1 && LightweightUtils.IsSupportedCookieType(visibleLights[mainLightIndex].lightType) && visibleLights[mainLightIndex].light.cookie != null);
 
             List<VisibleLight> visibleLights = lightData.visibleLights;
 

com.unity.render-pipelines.lightweight/LWRP/ShaderLibrary/Input.hlsl

 CBUFFER_START(_LightBuffer)
 float4 _MainLightPosition;
 half4 _MainLightColor;
-float4x4 _WorldToLight;
 
 half4 _AdditionalLightCount;
 float4 _AdditionalLightPosition[MAX_VISIBLE_LIGHTS];

com.unity.render-pipelines.lightweight/LWRP/ShaderLibrary/InputBuiltin.hlsl

 // We can have shadowMask only if we have lightmap, so no sampler
 TEXTURE2D(unity_ShadowMask);
 
-// Lightweight Pipeline Specific
-TEXTURE2D(_MainLightCookie);
-SAMPLER(sampler_MainLightCookie);
-
-
 // ----------------------------------------------------------------------------
 
 // TODO: all affine matrices should be 3x4.

com.unity.render-pipelines.lightweight/LWRP/ShaderLibrary/Lighting.hlsl

 ///////////////////////////////////////////////////////////////////////////////
 //                        Attenuation Functions                               /
 ///////////////////////////////////////////////////////////////////////////////
-half CookieAttenuation(float3 worldPos)
-{
-#ifdef _MAIN_LIGHT_COOKIE
-#ifdef _MAIN_LIGHT_DIRECTIONAL
-    float2 cookieUV = mul(_WorldToLight, float4(worldPos, 1.0)).xy;
-    return SAMPLE_TEXTURE2D(_MainLightCookie, sampler_MainLightCookie, cookieUV).a;
-#elif defined(_MAIN_LIGHT_SPOT)
-    float4 projPos = mul(_WorldToLight, float4(worldPos, 1.0));
-    float2 cookieUV = projPos.xy / projPos.w + 0.5;
-    return SAMPLE_TEXTURE2D(_MainLightCookie, sampler_MainLightCookie, cookieUV).a;
-#endif // POINT LIGHT cookie not supported
-#endif
-
-    return 1;
-}
 
 // Matches Unity Vanila attenuation
 // Attenuation smoothly decreases to light range.