Merge branch 'LightweightPipeline' into Unity-2017.3

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetInspector.cs

             public static GUIContent attenuationTextureLabel = new GUIContent("Attenuation Texture", "Light attenuation falloff texture");
         }
 
+        private int kMaxSupportedPixelLights = 5;
         private SerializedProperty m_LinearRenderingProperty;
         private SerializedProperty m_RenderScale;
         private SerializedProperty m_MaxPixelLights;
             EditorGUILayout.EndHorizontal();
             EditorGUILayout.BeginHorizontal();
             EditorGUILayout.LabelField(Styles.maxPixelLights);
-            m_MaxPixelLights.intValue = EditorGUILayout.IntSlider(m_MaxPixelLights.intValue, 0, 4);
+            m_MaxPixelLights.intValue = EditorGUILayout.IntSlider(m_MaxPixelLights.intValue, 0, kMaxSupportedPixelLights);
             EditorGUILayout.EndHorizontal();
             EditorGUILayout.PropertyField(m_SupportsVertexLightProp, Styles.enableVertexLightLabel);
             EditorGUILayout.PropertyField(m_MSAA, Styles.msaaContent);

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightPipelineUpgraders.cs

             LightweightShaderHelper.SetMaterialBlendMode(material);
             UpdateMaterialSpecularSource(material);
             LightweightShaderHelper.SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap"));
-            LightweightShaderHelper.SetKeyword(material, "_EMISSION", material.GetTexture("_EmissionMap"));
+
+            // A material's GI flag internally keeps track of whether emission is enabled at all, it's enabled but has no effect
+            // or is enabled and may be modified at runtime. This state depends on the values of the current flag and emissive color.
+            // The fixup routine makes sure that the material is in the correct state if/when changes are made to the mode or color.
+            MaterialEditor.FixupEmissiveFlag(material);
+            bool shouldEmissionBeEnabled = (material.globalIlluminationFlags & MaterialGlobalIlluminationFlags.EmissiveIsBlack) == 0;
+            LightweightShaderHelper.SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
         }
 
         private static void UpdateMaterialSpecularSource(Material material)

ScriptableRenderPipeline/LightweightPipeline/Editor/ShaderGUI/LightweightStandardSimpleLightingGUI.cs

         public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map");
         public static GUIContent emissionMapLabel = new GUIContent("Emission Map", "Emission Map");
 
-        public static GUIContent alphaCutoutWarning =
-            new GUIContent(
-                "This material has alpha cutout enabled. Alpha cutout has severe performance impact on mobile!");
-
-        public static GUIStyle warningStyle = new GUIStyle();
         public static readonly string[] blendNames = Enum.GetNames(typeof(UpgradeBlendMode));
         public static readonly string[] glossinessSourceNames = Enum.GetNames(typeof(GlossinessSource));
 
         FindMaterialProperties(properties);
 
         EditorGUI.BeginChangeCheck();
-        DoBlendMode();
+        {
+            DoBlendMode();
-        EditorGUILayout.Space();
-        DoSpecular();
+            EditorGUILayout.Space();
+            DoSpecular();
-        EditorGUILayout.Space();
-        m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, bumpMapProp);
+            EditorGUILayout.Space();
+            m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, bumpMapProp);
-        EditorGUILayout.Space();
-        DoEmissionArea(material);
+            EditorGUILayout.Space();
+            DoEmissionArea(material);
+            EditorGUI.BeginChangeCheck();
+            m_MaterialEditor.TextureScaleOffsetProperty(albedoMapProp);
+            if (EditorGUI.EndChangeCheck())
+                emissionMapProp.textureScaleAndOffset = albedoMapProp.textureScaleAndOffset; // Apply the main texture scale and offset to the emission texture as well, for Enlighten's sake
+        }
         if (EditorGUI.EndChangeCheck())
             LegacyBlinnPhongUpgrader.UpdateMaterialKeywords(material);
 
 
         EditorGUILayout.Space();
         EditorGUILayout.Space();
-
-        if ((UpgradeBlendMode)blendModeProp.floatValue == UpgradeBlendMode.Cutout)
-        {
-            Styles.warningStyle.normal.textColor = Color.yellow;
-            EditorGUILayout.LabelField(Styles.alphaCutoutWarning, Styles.warningStyle);
-        }
     }
 
     public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
             int glossSource = (int)glossinessSourceProp.floatValue;
             m_MaterialEditor.TexturePropertySingleLine(Styles.albedoGlosinessLabels[glossSource], albedoMapProp,
                 albedoColorProp);
-            m_MaterialEditor.TextureScaleOffsetProperty(albedoMapProp);
-        }
+            m_MaterialEditor.TextureScaleOffsetProperty(albedoMapProp);}
-            m_MaterialEditor.TextureScaleOffsetProperty(albedoMapProp);
             if (mode == UpgradeBlendMode.Cutout)
                 m_MaterialEditor.RangeProperty(alphaCutoffProp, "Cutoff");
         }

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

 using System;
+using System.Collections.Generic;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.PostProcessing;
 using UnityEngine.XR;
 
     public struct LightData
     {
-        public int pixelLightsCount;
+        public int additionalPixelLightsCount;
-        public int shadowLightIndex;
-        public bool isSingleLight;
+        public int mainLightIndex;
+        public bool hasAdditionalLights;
         public bool shadowsRendered;
     }
 
         private Vector4[] m_LightSpotDirections = new Vector4[kMaxVisibleLights];
 
         private Camera m_CurrCamera = null;
-        private LightType m_SingleLightType = LightType.Directional;
 
         private int m_LightIndicesCount = 0;
         private ComputeBuffer m_LightIndexListBuffer;
             m_Asset = asset;
 
             BuildShadowSettings();
+
+            PerFrameBuffer._GlossyEnvironmentColor = Shader.PropertyToID("_GlossyEnvironmentColor");
+            PerFrameBuffer._AttenuationTexture = Shader.PropertyToID("_AttenuationTexture");
+
+            PerCameraBuffer._MainLightPosition = Shader.PropertyToID("_MainLightPosition");
+            PerCameraBuffer._MainLightColor = Shader.PropertyToID("_MainLightColor");
+            PerCameraBuffer._MainLightAttenuationParams = Shader.PropertyToID("_MainLightAttenuationParams");
+            PerCameraBuffer._MainLightSpotDir = Shader.PropertyToID("_MainLightSpotDir");
+            PerCameraBuffer._AdditionalLightCount = Shader.PropertyToID("_AdditionalLightCount");
+            PerCameraBuffer._AdditionalLightPosition = Shader.PropertyToID("_AdditionalLightPosition");
+            PerCameraBuffer._AdditionalLightColor = Shader.PropertyToID("_AdditionalLightColor");
+            PerCameraBuffer._AdditionalLightAttenuationParams = Shader.PropertyToID("_AdditionalLightAttenuationParams");
+            PerCameraBuffer._AdditionalLightSpotDir = Shader.PropertyToID("_AdditionalLightSpotDir");
+
             m_ShadowMapTexture = Shader.PropertyToID("_ShadowMap");
             m_CameraColorTexture = Shader.PropertyToID("_CameraRT");
             m_CameraDepthTexture = Shader.PropertyToID("_CameraDepthTexture");
             // instead this should be forced when using SRP, since all SRP use linear lighting.
             GraphicsSettings.lightsUseLinearIntensity = true;
 
+            SetupPerFrameShaderConstants(ref context);
+
+            // Sort cameras array by camera depth
-                PostProcessLayer postProcessLayer;
-                RenderingConfiguration renderingConfig = SetupRendering(out postProcessLayer);
-                bool postProcessEnabled = LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.PostProcess);
                 ScriptableCullingParameters cullingParameters;
                 if (!CullResults.GetCullingParameters(m_CurrCamera, stereoEnabled, out cullingParameters))
                     continue;
 
-                // emit scene view UI
+#if UNITY_EDITOR
+                // Emit scene view UI
+#endif
-
-                // Render Shadow Map
-                if (lightData.shadowLightIndex > -1)
-                    lightData.shadowsRendered = RenderShadows(ref m_CullResults,
-                        ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, ref context);
+                ShadowPass(visibleLights, ref context, ref lightData);
+                ForwardPass(visibleLights, ref context, ref lightData, stereoEnabled);
-                // Setup camera matrices
-                context.SetupCameraProperties(m_CurrCamera, stereoEnabled);
+                context.Submit();
+            }
+        }
-                // Setup light and shadow shader constants
-                SetupShaderLightConstants(visibleLights, ref lightData, ref m_CullResults, ref context);
-                if (lightData.shadowsRendered)
-                    SetupShadowShaderConstants(ref context, ref visibleLights[lightData.shadowLightIndex],
-                        lightData.shadowLightIndex, m_ShadowCasterCascadesCount);
-                SetShaderKeywords(ref lightData, ref context);
+        private void ShadowPass(VisibleLight[] visibleLights, ref ScriptableRenderContext context, ref LightData lightData)
+        {
+            if (m_Asset.AreShadowsEnabled() && lightData.mainLightIndex != -1) 
+            {
+                VisibleLight mainLight = visibleLights[lightData.mainLightIndex];
+                if (mainLight.light.shadows != LightShadows.None)
+                    lightData.shadowsRendered = RenderShadows (ref m_CullResults,
+                        ref mainLight, lightData.mainLightIndex, ref context);
+            }
+        }
-                RendererConfiguration rendererSettings = GetRendererSettings(ref lightData);
+        private void ForwardPass(VisibleLight[] visibleLights, ref ScriptableRenderContext context, ref LightData lightData, bool stereoEnabled)
+        {
+            PostProcessLayer postProcessLayer;
+            RenderingConfiguration renderingConfig = SetupRendering(out postProcessLayer);
+            bool postProcessEnabled = LightweightUtils.HasFlag(renderingConfig, RenderingConfiguration.PostProcess);
+
+            CommandBuffer cmd = CommandBufferPool.Get("SetupShaderConstants");
+            SetupShaderLightConstants(cmd, visibleLights, ref lightData, ref m_CullResults, ref context);
+            SetShaderKeywords(cmd, ref lightData, visibleLights);
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release(cmd);
-                BeginForwardRendering(ref context, renderingConfig);
-                RenderOpaques(ref context, rendererSettings);
-                context.DrawSkybox(m_CurrCamera);
+            // Setup camera matrices
+            context.SetupCameraProperties(m_CurrCamera, stereoEnabled);
+ 
+            RendererConfiguration rendererSettings = GetRendererSettings(ref lightData);
-                if (postProcessEnabled)
-                    RenderPostProcess(ref context, postProcessLayer, true);
+            BeginForwardRendering(ref context, renderingConfig);
+            RenderOpaques(ref context, rendererSettings);
+            context.DrawSkybox(m_CurrCamera);
-                RenderTransparents(ref context, rendererSettings);
+            if (postProcessEnabled)
+                RenderPostProcess(ref context, postProcessLayer, true);
-                if (postProcessEnabled)
-                    RenderPostProcess(ref context, postProcessLayer, false);
+            RenderTransparents(ref context, rendererSettings);
-                EndForwardRendering(ref context, renderingConfig);
+            if (postProcessEnabled)
+                RenderPostProcess(ref context, postProcessLayer, false);
-                // Release temporary RT
-                var discardRT = CommandBufferPool.Get();
-                discardRT.ReleaseTemporaryRT(m_ShadowMapTexture);
-                discardRT.ReleaseTemporaryRT(m_CameraColorTexture);
-                discardRT.ReleaseTemporaryRT(m_CameraDepthTexture);
-                context.ExecuteCommandBuffer(discardRT);
-                CommandBufferPool.Release(discardRT);
+            EndForwardRendering(ref context, renderingConfig);
-                context.Submit();
-            }
+            // Release temporary RT
+            var discardRT = CommandBufferPool.Get();
+            discardRT.ReleaseTemporaryRT(m_ShadowMapTexture);
+            discardRT.ReleaseTemporaryRT(m_CameraColorTexture);
+            discardRT.ReleaseTemporaryRT(m_CameraDepthTexture);
+            context.ExecuteCommandBuffer(discardRT);
+            CommandBufferPool.Release(discardRT);
         }
 
         private void RenderOpaques(ref ScriptableRenderContext context, RendererConfiguration settings)
             };
 
             context.DrawRenderers(m_CullResults.visibleRenderers, ref transparentSettings, transparentFilterSettings);
-
         }
 
         private void BuildShadowSettings()
             return renderingConfig;
         }
 
-        private void InitializeLightData(VisibleLight[] lights, out LightData lightData)
+        private void InitializeLightData(VisibleLight[] visibleLights, out LightData lightData)
-            int lightsCount = lights.Length;
-            int maxPerPixelLights = Math.Min(m_Asset.MaxSupportedPixelLights, kMaxPerObjectLights);
-            lightData.pixelLightsCount = Math.Min(lightsCount, maxPerPixelLights);
-            lightData.vertexLightsCount = (m_Asset.SupportsVertexLight) ? Math.Min(lightsCount - lightData.pixelLightsCount, kMaxPerObjectLights) : 0;
+            int visibleLightsCount = visibleLights.Length;
-            // TODO: Handle Vertex lights in this case
-            lightData.isSingleLight = lightData.pixelLightsCount <= 1;
-            if (lightData.isSingleLight)
-                m_SingleLightType = (lightData.pixelLightsCount == 1) ? lights[0].lightType : LightType.Directional;
+            // kMaxPerObjectLights + 1 main light
+            int maxSupportedPixelLights = Math.Min(m_Asset.MaxSupportedPixelLights, kMaxPerObjectLights + 1);
+            int maxPixelLights = Math.Min(maxSupportedPixelLights, visibleLightsCount);
+            if (maxPixelLights <= 1)
+            {
+                lightData.mainLightIndex = maxPixelLights - 1;
+                lightData.additionalPixelLightsCount = 0;
+            }
+            else
+            {
+                lightData.mainLightIndex = GetMainLightIndex(visibleLights);
+                lightData.additionalPixelLightsCount = maxPixelLights - 1;
+            }
+            lightData.vertexLightsCount = (m_Asset.SupportsVertexLight) ? Math.Min(visibleLightsCount - maxPixelLights, kMaxPerObjectLights) : 0;
+            lightData.hasAdditionalLights = (lightData.additionalPixelLightsCount + lightData.vertexLightsCount) > 0;
+        }
-            InitializeMainShadowLightIndex(lights, out lightData.shadowLightIndex);
+        // How main light is decided:
+        // 1) If shadows are enabled and at least a shadow light is present:
+        // Main light is a shadow light. Directional shadow light has priority over the other supported
+        // shadow lights types.
+        // Lightweight pipeline only supports 1 single directional shadow light.
+        // Any additional pixel lights don't cast shadows.
+        // 
+        // 2) If shadows are disabled or no shadow light is present then main light is the main brighest directional
+        // 3) If neither a shadow light or main light is first visible light.
+        private int GetMainLightIndex(VisibleLight[] lights)
+        {
+            bool shadowsEnabled = m_Asset.AreShadowsEnabled();
+            int mainDirectional = -1;
+            int mainShadowLight = -1;
+
+            for (int i = 0; i < lights.Length; ++i) 
+            {
+                if (shadowsEnabled && LightweightUtils.IsSupportedShadowType (lights[i].lightType) && lights[i].light.shadows != LightShadows.None) 
+                {
+                    // Shadow Type priority: Soft > Hard > None
+                    if (mainShadowLight < 0 || lights[i].light.shadows > lights[mainShadowLight].light.shadows)
+                        mainShadowLight = i;
+                }
+
+                if (lights[i].lightType == LightType.Directional) 
+                {
+                    if (mainDirectional < 0 || lights[i].light.intensity > lights[mainDirectional].light.intensity)
+                        mainDirectional = i;
+                }
+            }
+
+            if (mainShadowLight >= 0) 
+            {
+                if (mainDirectional > 0 && lights[mainDirectional].light.shadows != LightShadows.None)
+                    return mainDirectional;
+                else
+                    return mainShadowLight;
+            } 
+
+            if (mainDirectional > 0)
+                return mainDirectional;
+            
+            return 0;
         }
 
         private void InitializeLightConstants(VisibleLight[] lights, int lightIndex, out Vector4 lightPos, out Vector4 lightColor, out Vector4 lightSpotDir,
             }
         }
 
-        private void SetupShaderLightConstants(VisibleLight[] lights, ref LightData lightData, ref CullResults cullResults, ref ScriptableRenderContext context)
+        private void SetupPerFrameShaderConstants(ref ScriptableRenderContext context)
-            CommandBuffer cmd = CommandBufferPool.Get("SetupSingleLightConstants");
-
-            cmd.SetGlobalVector("_GlossyEnvironmentColor", glossyEnvColor);
-            if (m_Asset.AttenuationTexture != null) cmd.SetGlobalTexture("_AttenuationTexture", m_Asset.AttenuationTexture);
+            CommandBuffer cmd = CommandBufferPool.Get("SetupPerFrameConstants");
+            cmd.SetGlobalVector(PerFrameBuffer._GlossyEnvironmentColor, glossyEnvColor);
+            if (m_Asset.AttenuationTexture != null) cmd.SetGlobalTexture(PerFrameBuffer._AttenuationTexture, m_Asset.AttenuationTexture);
+            context.ExecuteCommandBuffer(cmd);
+            CommandBufferPool.Release (cmd);
+        }
-            if (lightData.isSingleLight)
-                SetupShaderSingleLightConstants(cmd, lights, (lightData.pixelLightsCount > 0) ? 0 : -1, ref context);
-            else
-                SetupShaderLightListConstants(cmd, lights, ref lightData, ref context);
+        private void SetupShaderLightConstants(CommandBuffer cmd, VisibleLight[] lights, ref LightData lightData, ref CullResults cullResults, ref ScriptableRenderContext context)
+        {
+            // 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);
+            }
-            context.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
+            if (lightData.hasAdditionalLights)
+                SetupAdditionalListConstants(cmd, lights, ref lightData, ref context);
-        private void SetupShaderSingleLightConstants(CommandBuffer cmd, VisibleLight[] lights, int lightIndex, ref ScriptableRenderContext context)
+        private void SetupMainLightConstants(CommandBuffer cmd, VisibleLight[] lights, int lightIndex, ref ScriptableRenderContext context)
-            cmd.SetGlobalVector("_LightPosition", lightPos);
-            cmd.SetGlobalColor("_LightColor", lightColor);
-            cmd.SetGlobalVector("_LightSpotDir", lightSpotDir);
-            cmd.SetGlobalVector("_LightAttenuationParams", lightAttenuationParams);
+            cmd.SetGlobalVector(PerCameraBuffer._MainLightPosition, lightPos);
+            cmd.SetGlobalColor(PerCameraBuffer._MainLightColor, lightColor);
+            cmd.SetGlobalVector(PerCameraBuffer._MainLightSpotDir, lightSpotDir);
+            cmd.SetGlobalVector(PerCameraBuffer._MainLightAttenuationParams, lightAttenuationParams);
-        private void SetupShaderLightListConstants(CommandBuffer cmd, VisibleLight[] lights, ref LightData lightData, ref ScriptableRenderContext context)
+        private void SetupAdditionalListConstants(CommandBuffer cmd, VisibleLight[] lights, ref LightData lightData, ref ScriptableRenderContext context)
-            int maxLights = Math.Min(kMaxVisibleLights, lights.Length);
+            int totalLightCount = lights.Length;
+            int maxLights = Math.Min(kMaxVisibleLights, totalLightCount);
-            for (int i = 0; i < maxLights; ++i)
-                InitializeLightConstants(lights, i, out m_LightPositions[i], out m_LightColors[i], out m_LightSpotDirections[i], out m_LightAttenuations[i]);
-
-            // Lightweight pipeline only upload kMaxVisibleLights to shader cbuffer.
-            // We tell the pipe to disable remaining lights by setting it to -1.
-            for (int i = kMaxVisibleLights; i < lightIndexMap.Length; ++i)
-                lightIndexMap[i] = -1;
+            int lightIter = 0;
+            for (int i = 0; i < totalLightCount; ++i) 
+            {
+                if (i == lightData.mainLightIndex || lightIter >= maxLights) 
+                {
+                    lightIndexMap[i] = -1;
+                    continue;
+                }
+
+                InitializeLightConstants(lights, i, out m_LightPositions[lightIter], out m_LightColors[lightIter], out m_LightSpotDirections[lightIter], out m_LightAttenuations[lightIter]);
+                lightIndexMap[i] = lightIter;
+                lightIter++;
+            }
-            cmd.SetGlobalVector("globalLightCount", new Vector4 (lightData.pixelLightsCount, lightData.vertexLightsCount, 0.0f, 0.0f));
-            cmd.SetGlobalVectorArray ("globalLightPos", m_LightPositions);
-            cmd.SetGlobalVectorArray ("globalLightColor", m_LightColors);
-            cmd.SetGlobalVectorArray ("globalLightAtten", m_LightAttenuations);
-            cmd.SetGlobalVectorArray ("globalLightSpotDir", m_LightSpotDirections);
+            cmd.SetGlobalVector(PerCameraBuffer._AdditionalLightCount, new Vector4 (lightData.additionalPixelLightsCount, lightData.vertexLightsCount, 0.0f, 0.0f));
+            cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightPosition, m_LightPositions);
+            cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightColor, m_LightColors);
+            cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightAttenuationParams, m_LightAttenuations);
+            cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightSpotDir, m_LightSpotDirections);
+        }
+
+        private void SetupShadowShaderConstants(CommandBuffer cmd, ref ScriptableRenderContext context, ref VisibleLight shadowLight, int cascadeCount)
+        {
+            Vector3 shadowLightDir = Vector3.Normalize(shadowLight.localToWorld.GetColumn(2));
+
+            float bias = shadowLight.light.shadowBias * 0.1f;
+            float normalBias = shadowLight.light.shadowNormalBias;
+            float shadowResolution = m_ShadowSlices[0].shadowResolution;
+
+            const int maxShadowCascades = 4;
+            Matrix4x4[] shadowMatrices = new Matrix4x4[maxShadowCascades];
+            for (int i = 0; i < cascadeCount; ++i)
+                shadowMatrices[i] = (cascadeCount >= i) ? m_ShadowSlices[i].shadowTransform : Matrix4x4.identity;
+
+            // TODO: shadow resolution per cascade in case cascades endup being supported.
+            float invShadowResolution = 1.0f / shadowResolution;
+            float[] pcfKernel =
+            {
+                -0.5f * invShadowResolution, 0.5f * invShadowResolution,
+                0.5f * invShadowResolution, 0.5f * invShadowResolution,
+                -0.5f * invShadowResolution, -0.5f * invShadowResolution,
+                0.5f * invShadowResolution, -0.5f * invShadowResolution
+            };
+
+            cmd.SetGlobalMatrixArray("_WorldToShadow", shadowMatrices);
+            cmd.SetGlobalVectorArray("_DirShadowSplitSpheres", m_DirectionalShadowSplitDistances);
+            cmd.SetGlobalVector("_ShadowLightDirection", new Vector4(-shadowLightDir.x, -shadowLightDir.y, -shadowLightDir.z, 0.0f));
+            cmd.SetGlobalVector("_ShadowData", new Vector4(0.0f, bias, normalBias, 0.0f));
+            cmd.SetGlobalFloatArray("_PCFKernel", pcfKernel);
-        private void SetShaderKeywords(ref LightData lightData, ref ScriptableRenderContext context)
+        private void SetShaderKeywords(CommandBuffer cmd, ref LightData lightData, VisibleLight[] visibleLights)
-            CommandBuffer cmd = new CommandBuffer() { name = "SetShaderKeywords" };
-            SetShaderKeywords(cmd, lightData.shadowsRendered, lightData.isSingleLight, lightData.vertexLightsCount > 0);
-            context.ExecuteCommandBuffer(cmd);
-            cmd.Dispose();
+            LightweightUtils.SetKeyword(cmd, "_LIGHTWEIGHT_FORCE_LINEAR", m_Asset.ForceLinearRendering);
+            LightweightUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", lightData.vertexLightsCount > 0);
+            LightweightUtils.SetKeyword(cmd, "_ATTENUATION_TEXTURE", m_Asset.AttenuationTexture != null);
+
+            int mainLightIndex = lightData.mainLightIndex;
+            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_PIXEL_LIGHTS", lightData.additionalPixelLightsCount > 0);
+
+            string[] shadowKeywords = new string[] { "_HARD_SHADOWS", "_SOFT_SHADOWS", "_HARD_SHADOWS_CASCADES", "_SOFT_SHADOWS_CASCADES" };
+            for (int i = 0; i < shadowKeywords.Length; ++i)
+                cmd.DisableShaderKeyword(shadowKeywords[i]);
+
+            if (m_Asset.AreShadowsEnabled() && lightData.shadowsRendered)
+            {
+                int keywordIndex = (int)m_Asset.ShadowSetting - 1;
+                if (m_Asset.CascadeCount > 1)
+                    keywordIndex += 2;
+                cmd.EnableShaderKeyword(shadowKeywords[keywordIndex]);
+            }
         }
 
         private bool RenderShadows(ref CullResults cullResults, ref VisibleLight shadowLight, int shadowLightIndex, ref ScriptableRenderContext context)
             return resolution;
         }
 
-        private void SetupShadowShaderConstants(ref ScriptableRenderContext context, ref VisibleLight shadowLight, int shadowLightIndex, int cascadeCount)
-        {
-            Vector3 shadowLightDir = Vector3.Normalize(shadowLight.localToWorld.GetColumn(2));
-
-            float bias = shadowLight.light.shadowBias * 0.1f;
-            float normalBias = shadowLight.light.shadowNormalBias;
-            float shadowResolution = m_ShadowSlices[0].shadowResolution;
-
-            const int maxShadowCascades = 4;
-            Matrix4x4[] shadowMatrices = new Matrix4x4[maxShadowCascades];
-            for (int i = 0; i < cascadeCount; ++i)
-                shadowMatrices[i] = (cascadeCount >= i) ? m_ShadowSlices[i].shadowTransform : Matrix4x4.identity;
-
-            // TODO: shadow resolution per cascade in case cascades endup being supported.
-            float invShadowResolution = 1.0f / shadowResolution;
-            float[] pcfKernel =
-            {
-                -0.5f * invShadowResolution, 0.5f * invShadowResolution,
-                0.5f * invShadowResolution, 0.5f * invShadowResolution,
-                -0.5f * invShadowResolution, -0.5f * invShadowResolution,
-                0.5f * invShadowResolution, -0.5f * invShadowResolution
-            };
-
-            var setupShadow = CommandBufferPool.Get("SetupShadowShaderConstants");
-            setupShadow.SetGlobalMatrixArray("_WorldToShadow", shadowMatrices);
-            setupShadow.SetGlobalVectorArray("_DirShadowSplitSpheres", m_DirectionalShadowSplitDistances);
-            setupShadow.SetGlobalVector("_ShadowLightDirection", new Vector4(-shadowLightDir.x, -shadowLightDir.y, -shadowLightDir.z, 0.0f));
-            setupShadow.SetGlobalVector("_ShadowData", new Vector4(shadowLightIndex, bias, normalBias, 0.0f));
-            setupShadow.SetGlobalFloatArray("_PCFKernel", pcfKernel);
-            context.ExecuteCommandBuffer(setupShadow);
-            CommandBufferPool.Release(setupShadow);
-        }
-
-        private void SetShaderKeywords(CommandBuffer cmd, bool renderShadows, bool singleLight, bool vertexLightSupport)
-        {
-            LightweightUtils.SetKeyword(cmd, "_LIGHTWEIGHT_FORCE_LINEAR", m_Asset.ForceLinearRendering);
-            LightweightUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightSupport);
-            LightweightUtils.SetKeyword(cmd, "_ATTENUATION_TEXTURE", m_Asset.AttenuationTexture != null);
-
-            if (!singleLight)
-            {
-                LightweightUtils.SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", false);
-                LightweightUtils.SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", false);
-                LightweightUtils.SetKeyword(cmd, "_SINGLE_POINT_LIGHT", false);
-            }
-            else
-            {
-                switch (m_SingleLightType)
-                {
-                        case LightType.Directional:
-                        LightweightUtils.SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", true);
-                        LightweightUtils.SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", false);
-                        LightweightUtils.SetKeyword(cmd, "_SINGLE_POINT_LIGHT", false);
-                        break;
-
-                        case LightType.Spot:
-                        LightweightUtils.SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", false);
-                        LightweightUtils.SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", true);
-                        LightweightUtils.SetKeyword(cmd, "_SINGLE_POINT_LIGHT", false);
-                        break;
-
-                        case LightType.Point:
-                        LightweightUtils.SetKeyword(cmd, "_SINGLE_DIRECTIONAL_LIGHT", false);
-                        LightweightUtils.SetKeyword(cmd, "_SINGLE_SPOT_LIGHT", false);
-                        LightweightUtils.SetKeyword(cmd, "_SINGLE_POINT_LIGHT", true);
-                        break;
-                }
-            }
-
-            string[] shadowKeywords = new string[] { "_HARD_SHADOWS", "_SOFT_SHADOWS", "_HARD_SHADOWS_CASCADES", "_SOFT_SHADOWS_CASCADES" };
-            for (int i = 0; i < shadowKeywords.Length; ++i)
-                cmd.DisableShaderKeyword(shadowKeywords[i]);
-
-            if (renderShadows && m_Asset.CurrShadowType != ShadowType.NO_SHADOW)
-            {
-                int keywordIndex = (int)m_Asset.CurrShadowType - 1;
-                if (m_Asset.CascadeCount > 1)
-                    keywordIndex += 2;
-                cmd.EnableShaderKeyword(shadowKeywords[keywordIndex]);
-            }
-        }
-
-        private void InitializeMainShadowLightIndex(VisibleLight[] lights, out int shadowIndex)
-        {
-            shadowIndex = -1;
-            if (m_Asset.CurrShadowType == ShadowType.NO_SHADOW)
-                return;
-
-            float maxIntensity = -1;
-            for (int i = 0; i < lights.Length; ++i)
-            {
-                Light light = lights[i].light;
-                if (light.shadows != LightShadows.None && IsSupportedShadowType(light.type) && light.intensity > maxIntensity)
-                {
-                    shadowIndex = i;
-                    maxIntensity = light.intensity;
-                }
-            }
-        }
-
-        private bool IsSupportedShadowType(LightType type)
-        {
-            return (type == LightType.Directional || type == LightType.Spot);
-        }
-
         private void BeginForwardRendering(ref ScriptableRenderContext context, RenderingConfiguration renderingConfig)
         {
             RenderTargetIdentifier colorRT = BuiltinRenderTextureType.CameraTarget;
         RendererConfiguration GetRendererSettings(ref LightData lightData)
         {
             RendererConfiguration settings = RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
-            if (!lightData.isSingleLight)
+            if (lightData.hasAdditionalLights)
                 settings |= RendererConfiguration.PerObjectLightIndices8;
             return settings;
         }

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_Script: {fileID: 11500000, guid: bf2edee5c58d82540a51f03df9d42094, type: 3}
   m_Name: LightweightPipelineAsset
   m_EditorClassIdentifier: 
-  m_MaxPixelLights: 4
+  m_MaxPixelLights: 5
   m_SupportsVertexLight: 1
   m_MSAA: 4
   m_RenderScale: 1

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.cs

         private static readonly string m_PipelineFolder = "Assets/ScriptableRenderPipeline/LightweightPipeline";
         private static readonly string m_AssetName = "LightweightPipelineAsset.asset";
 
+        [SerializeField] private int m_MaxPixelLights = 1;
+        [SerializeField] private bool m_SupportsVertexLight = true;
+        [SerializeField] private MSAAQuality m_MSAA = MSAAQuality.Disabled;
+        [SerializeField] private float m_RenderScale = 1.0f;
+        [SerializeField] private ShadowType m_ShadowType = ShadowType.HARD_SHADOWS;
+        [SerializeField] private ShadowResolution m_ShadowAtlasResolution = ShadowResolution._1024;
+        [SerializeField] private float m_ShadowNearPlaneOffset = 2.0f;
+        [SerializeField] private float m_ShadowDistance = 50.0f;
+        [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;
+        [SerializeField] private Material m_DefaultParticleMaterial;
+        [SerializeField] private Material m_DefaultLineMaterial;
+        [SerializeField] private Material m_DefaultSpriteMaterial;
+        [SerializeField] private Material m_DefaultUIMaterial;
+        [SerializeField] private Shader m_DefaultShader;
+
 #if UNITY_EDITOR
         [UnityEditor.MenuItem("RenderPipeline/LightweightPipeline/Create Pipeline Asset", false, 15)]
         static void CreateLightweightPipeline()
             DestroyCreatedInstances();
         }
 
-        [SerializeField] private int m_MaxPixelLights = 1;
-        [SerializeField] private bool m_SupportsVertexLight = true;
-        [SerializeField] private MSAAQuality m_MSAA = MSAAQuality.Disabled;
-        [SerializeField] private float m_RenderScale = 1.0f;
-        [SerializeField] private ShadowType m_ShadowType = ShadowType.HARD_SHADOWS;
-        [SerializeField] private ShadowResolution m_ShadowAtlasResolution = ShadowResolution._1024;
-        [SerializeField] private float m_ShadowNearPlaneOffset = 2.0f;
-        [SerializeField] private float m_ShadowDistance = 50.0f;
-        [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;
-        [SerializeField] private Material m_DefaultParticleMaterial;
-        [SerializeField] private Material m_DefaultLineMaterial;
-        [SerializeField] private Material m_DefaultSpriteMaterial;
-        [SerializeField] private Material m_DefaultUIMaterial;
-        [SerializeField] private Shader m_DefaultShader;
+        public bool AreShadowsEnabled()
+        {
+            return ShadowSetting != ShadowType.NO_SHADOW;
+        }
 
         public int MaxSupportedPixelLights
         {
             set { m_RenderScale = value; }
         }
 
-        public ShadowType CurrShadowType
+        public ShadowType ShadowSetting
         {
             get { return m_ShadowType; }
             private set { m_ShadowType = value; }

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineUtils.cs

                 cmd.DisableShaderKeyword(keyword);
         }
 
+        public static bool IsSupportedShadowType(LightType lightType)
+        {
+            return lightType == LightType.Directional || lightType == LightType.Spot;
+        }
+
         public static bool PlatformSupportsMSAABackBuffer()
         {
 #if UNITY_ANDROID || UNITY_IPHONE || UNITY_TVOS || UNITY_SAMSUNGTV

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightInput.cginc

 
 // Main light initialized without indexing
 #define INITIALIZE_MAIN_LIGHT(light) \
-    light.pos = _LightPosition; \
-    light.color = _LightColor; \
-    light.atten = _LightAttenuationParams; \
-    light.spotDir = _LightSpotDir;
+    light.pos = _MainLightPosition; \
+    light.color = _MainLightColor; \
+    light.atten = _MainLightAttenuationParams; \
+    light.spotDir = _MainLightSpotDir;
-                            light.pos = globalLightPos[lightIndex]; \
-                            light.color = globalLightColor[lightIndex]; \
-                            light.atten = globalLightAtten[lightIndex]; \
-                            light.spotDir = globalLightSpotDir[lightIndex]
+                            light.pos = _AdditionalLightPosition[lightIndex]; \
+                            light.color = _AdditionalLightColor[lightIndex]; \
+                            light.atten = _AdditionalLightAttenuationParams[lightIndex]; \
+                            light.spotDir = _AdditionalLightSpotDir[lightIndex]
-#if !(defined(_SINGLE_DIRECTIONAL_LIGHT) || defined(_SINGLE_SPOT_LIGHT) || defined(_SINGLE_POINT_LIGHT))
-#define _MULTIPLE_LIGHTS
+#if (defined(_MAIN_DIRECTIONAL_LIGHT) || defined(_MAIN_SPOT_LIGHT) || defined(_MAIN_POINT_LIGHT))
+#define _MAIN_LIGHT
 #endif
 
 #ifdef _SPECULAR_SETUP
 #endif
 
 #if defined(UNITY_COLORSPACE_GAMMA) && defined(_LIGHTWEIGHT_FORCE_LINEAR)
-// Ideally we want an approximation of gamma curve 2.0 to save ALU on GPU but as off now it won't match the GammaToLinear conversion of props in engine
-//#define LIGHTWEIGHT_GAMMA_TO_LINEAR(sRGB) sRGB * (sRGB * (sRGB * 0.305306011h + 0.682171111h) + 0.012522878h)
-//#define LIGHTWEIGHT_LINEAR_TO_GAMMA(linRGB) max(1.055h * pow(max(linRGB, 0.h), 0.416666667h) - 0.055h, 0.h)
-
 
 struct LightInput
 {
     half4 spotDir;
 };
 
-sampler2D _AttenuationTexture;
-
-// Per object light list data
-#ifdef _MULTIPLE_LIGHTS
+CBUFFER_START(_PerObject)
+half _Shininess;
+CBUFFER_END
-// The variables are very similar to built-in unity_LightColor, unity_LightPosition,
-// unity_LightAtten, unity_SpotDirection as used by the VertexLit shaders, except here
-// we use world space positions instead of view space.
-half4 globalLightCount;
-half4 globalLightColor[MAX_VISIBLE_LIGHTS];
-float4 globalLightPos[MAX_VISIBLE_LIGHTS];
-half4 globalLightSpotDir[MAX_VISIBLE_LIGHTS];
-float4 globalLightAtten[MAX_VISIBLE_LIGHTS];
-#else
-float4 _LightPosition;
-half4 _LightColor;
-float4 _LightAttenuationParams;
-half4 _LightSpotDir;
-#endif
+CBUFFER_START(_PerCamera)
+float4 _MainLightPosition;
+half4 _MainLightColor;
+float4 _MainLightAttenuationParams;
+half4 _MainLightSpotDir;
-half _Shininess;
+half4 _AdditionalLightCount;
+float4 _AdditionalLightPosition[MAX_VISIBLE_LIGHTS];
+half4 _AdditionalLightColor[MAX_VISIBLE_LIGHTS];
+float4 _AdditionalLightAttenuationParams[MAX_VISIBLE_LIGHTS];
+half4 _AdditionalLightSpotDir[MAX_VISIBLE_LIGHTS];
+CBUFFER_END
+
+CBUFFER_START(_PerFrame)
+sampler2D _AttenuationTexture;
+CBUFFER_END
 
 struct LightweightVertexInput
 {

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightLighting.cginc

     // normalized light dir
     lightDirection = half3(posToLightVec * rsqrt(distanceSqr));
 
-#if  !(defined(_SINGLE_POINT_LIGHT) || defined(_SINGLE_DIRECTIONAL_LIGHT))
-#endif
 
     return half(lightAtten);
 }
     float4 attenuationParams = lightInput.atten;
-#ifdef _SINGLE_DIRECTIONAL_LIGHT
-    // Light pos holds normalized light dir
-    lightDirection = lightInput.pos;
-    return 1.0;
-#else
-    // TODO: Test separating dir lights into diff loop by sorting on the pipe and setting -1 on LightIndexMap.
 #ifdef _ATTENUATION_TEXTURE
     float u = (distanceSqr * attenuationParams.z) / attenuationParams.w;
     float lightAtten = tex2D(_AttenuationTexture, float2(u, 0.0)).a;
     // normalized light dir
     lightDirection = half3(posToLightVec * rsqrt(distanceSqr));
 
-#ifndef _SINGLE_POINT_LIGHT
-#endif
+}
-#endif // _SINGLE_DIRECTIONAL_LIGHT
+inline half ComputeMainLightAttenuation(LightInput lightInput, half3 normal, float3 worldPos, out half3 lightDirection)
+{
+#ifdef _MAIN_DIRECTIONAL_LIGHT
+    // Light pos holds normalized light dir
+    lightDirection = lightInput.pos;
+    return 1.0;
+#else
+    return ComputeLightAttenuation(lightInput, normal, worldPos, lightDirection);
+#endif
 }
 
 inline half3 LightingLambert(half3 diffuseColor, half3 lightDir, half3 normal, half atten)

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPassLit.cginc

     half3 color = LightweightBRDFIndirect(brdfData, indirectLight, roughness2, fresnelTerm);
     half3 lightDirection;
 
-#ifndef _MULTIPLE_LIGHTS
+#ifdef _MAIN_LIGHT
-    half lightAtten = ComputeLightAttenuation(light, normal, i.posWS.xyz, lightDirection);
+    half lightAtten = ComputeMainLightAttenuation(light, normal, i.posWS.xyz, lightDirection);
 
 #ifdef _SHADOWS
     lightAtten *= ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
     half3 radiance = light.color * (lightAtten * NdotL);
     color += LightweightBDRF(brdfData, roughness2, normal, lightDirection, i.viewDir.xyz) * radiance;
-#else
-
-#ifdef _SHADOWS
-    half shadowAttenuation = ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
-    int pixelLightCount = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
+
+#ifdef _ADDITIONAL_PIXEL_LIGHTS
+    int pixelLightCount = min(_AdditionalLightCount.x, unity_LightIndicesOffsetAndCount.y);
     for (int lightIter = 0; lightIter < pixelLightCount; ++lightIter)
     {
         LightInput light;
-#ifdef _SHADOWS
-        lightAtten *= max(shadowAttenuation, half(lightIndex != _ShadowData.x));
-#endif
+
         half NdotL = saturate(dot(normal, lightDirection));
         half3 radiance = light.color * (lightAtten * NdotL);
         color += LightweightBDRF(brdfData, roughness2, normal, lightDirection, i.viewDir.xyz) * radiance;
 
     half3 lightDirection;
 
-#ifndef _MULTIPLE_LIGHTS
+#if defined(LIGHTMAP_ON)
+    half3 color = DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, i.uv01.zw)) * diffuse;
+#else
+    half3 color = (SHEvalLinearL0L1(half4(normal, 1.0)) + i.fogCoord.yzw) * diffuse;
+#endif
+
+#ifdef _MAIN_LIGHT
-    half lightAtten = ComputeLightAttenuation(lightInput, normal, worldPos, lightDirection);
+    half lightAtten = ComputeMainLightAttenuation(lightInput, normal, worldPos, lightDirection);
-    half3 color = LightingBlinnPhong(diffuse, specularGloss, lightDirection, normal, viewDir, lightAtten) * lightInput.color;
+    color += LightingBlinnPhong(diffuse, specularGloss, lightDirection, normal, viewDir, lightAtten) * lightInput.color;
-    half3 color = LightingLambert(diffuse, lightDirection, normal, lightAtten) * lightInput.color;
+    color += LightingLambert(diffuse, lightDirection, normal, lightAtten) * lightInput.color;
-#else
-    half3 color = half3(0, 0, 0);
-
-#ifdef _SHADOWS
-    half shadowAttenuation = ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
-    int pixelLightCount = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
+
+#ifdef _ADDITIONAL_PIXEL_LIGHTS
+    int pixelLightCount = min(_AdditionalLightCount.x, unity_LightIndicesOffsetAndCount.y);
     for (int lightIter = 0; lightIter < pixelLightCount; ++lightIter)
     {
         LightInput lightData;
-#ifdef _SHADOWS
-        lightAtten *= max(shadowAttenuation, half(lightIndex != _ShadowData.x));
-#endif
 
 #ifdef LIGHTWEIGHT_SPECULAR_HIGHLIGHTS
         color += LightingBlinnPhong(diffuse, specularGloss, lightDirection, normal, viewDir, lightAtten) * lightData.color;
     }
 
-#endif // _MULTIPLE_LIGHTS
-
-#ifdef _EMISSION
-    color += LIGHTWEIGHT_GAMMA_TO_LINEAR(tex2D(_EmissionMap, i.uv01.xy).rgb) * _EmissionColor;
-#else
-    color += _EmissionColor;
-#endif
-
-#if defined(LIGHTMAP_ON)
-    color += DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, i.uv01.zw)) * diffuse;
-#else
-    color += (SHEvalLinearL0L1(half4(normal, 1.0)) + i.fogCoord.yzw) * diffuse;
-#endif
+#endif // _ADDITIONAL_PIXEL_LIGHTS
-#if _REFLECTION_CUBEMAP
-    // TODO: we can use reflect vec to compute specular instead of half when computing cubemap reflection
-    half3 reflectVec = reflect(-i.viewDir.xyz, normal);
-    color += texCUBE(_Cube, reflectVec).rgb * specularGloss.rgb;
-#elif defined(_REFLECTION_PROBE)
-    half3 reflectVec = reflect(-i.viewDir.xyz, normal);
-    half4 reflectionProbe = UNITY_SAMPLE_TEXCUBE(unity_SpecCube0, reflectVec);
-    color += reflectionProbe.rgb * (reflectionProbe.a * unity_SpecCube0_HDR.x) * specularGloss.rgb;
-#endif
-
+    color += EmissionLW(i.uv01.xy);
-
     return OutputColor(color, alpha);
 };
 

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandard.shader

             #pragma shader_feature _ _OCCLUSIONMAP
             #pragma shader_feature _PARALLAXMAP
 
-            #pragma multi_compile _ _SINGLE_DIRECTIONAL_LIGHT _SINGLE_SPOT_LIGHT _SINGLE_POINT_LIGHT
+            #pragma multi_compile _ _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
+            #pragma multi_compile _ _ADDITIONAL_PIXEL_LIGHTS
             #pragma multi_compile _ _LIGHTWEIGHT_FORCE_LINEAR
             #pragma multi_compile _ UNITY_SINGLE_PASS_STEREO STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
             #pragma multi_compile _ LIGHTMAP_ON
         }
     }
     FallBack "Standard"
-    CustomEditor "LightweightStandardShaderGUI"
+    CustomEditor "LightweightStandardGUI"
 }
 

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardSimpleLighting.shader

         _Glossiness("Glossiness", Range(0.0, 1.0)) = 0.5
         [Enum(Specular Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel("Smoothness texture channel", Float) = 0
 
-        _Cube ("Reflection Cubemap", CUBE) = "" {}
-        _ReflectionSource("Reflection Source", Float) = 0
-
         [HideInInspector] _SpecSource("Specular Color Source", Float) = 0.0
         _SpecColor("Specular", Color) = (1.0, 1.0, 1.0)
         _SpecGlossMap("Specular", 2D) = "white" {}
             #pragma shader_feature _NORMALMAP
             #pragma shader_feature _EMISSION
 
+            #pragma multi_compile _ _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
+            #pragma multi_compile _ _ADDITIONAL_PIXEL_LIGHTS
-            #pragma multi_compile _ _SINGLE_DIRECTIONAL_LIGHT _SINGLE_SPOT_LIGHT _SINGLE_POINT_LIGHT
             #pragma multi_compile _ LIGHTMAP_ON
             #pragma multi_compile _ _HARD_SHADOWS _SOFT_SHADOWS _HARD_SHADOWS_CASCADES _SOFT_SHADOWS_CASCADES
             #pragma multi_compile _ _VERTEX_LIGHTS
         }
     }
     Fallback "Standard (Specular setup)"
-    CustomEditor "LightweightPipelineMaterialEditor"
+    CustomEditor "LightweightStandardSimpleLightingGUI"
 }

ScriptableRenderPipeline/LightweightPipeline/LightweightConstantBuffer.cs

+using UnityEngine;
+
+namespace UnityEngine.Experimental.Rendering.LightweightPipeline
+{
+    public static class PerFrameBuffer
+    {
+        public static int _GlossyEnvironmentColor;
+        public static int _AttenuationTexture;
+    }
+
+    public static class PerCameraBuffer
+    {
+        public static int _MainLightPosition;
+        public static int _MainLightColor;
+        public static int _MainLightAttenuationParams;
+        public static int _MainLightSpotDir;
+
+        public static int _AdditionalLightCount;
+        public static int _AdditionalLightPosition;
+        public static int _AdditionalLightColor;
+        public static int _AdditionalLightAttenuationParams;
+        public static int _AdditionalLightSpotDir;
+    }
+}

ScriptableRenderPipeline/LightweightPipeline/LightweightConstantBuffer.cs.meta

+fileFormatVersion: 2
+guid: 2462b9b2044ad4b62a8c7fcd6f012f8e
+timeCreated: 1506514389
+licenseType: Free
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: