Backport pull request #1336 into 2018.1

ScriptableRenderPipeline/Core/CoreRP/Shadow/Shadow.cs

                 int requestIdx        = shadowRequests[i];
                 VisibleLight vl       = lights[requestIdx];
                 int facecount         = 0;
-                GPUShadowType shadowType = GPUShadowType.Point;
+                GPUShadowType shadowType = GetShadowLightType( vl.light );
-                bool    add             = (distToCam < asd.shadowFadeDistance || vl.lightType == LightType.Directional) && m_ShadowSettings.enabled;
+                bool    add             = shadowType != GPUShadowType.Unknown && (distToCam < asd.shadowFadeDistance || vl.lightType == LightType.Directional) && m_ShadowSettings.enabled;
 
                 if( add )
                 {
                             add = --m_MaxShadows[(int)GPUShadowType.Directional, 0] >= 0;
-                            shadowType = GPUShadowType.Directional;
-                            shadowType = GPUShadowType.Point;
-                            shadowType = GPUShadowType.Spot;
                             facecount = 1;
                             break;
                     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.cs

 
         void DrawFeatures()
         {
-            bool disabledScope = settings.isCompletelyBaked
-                || m_LightShape == LightShape.Line
-                || m_LightShape == LightShape.Rectangle;
+            bool disabledScope = m_LightShape == LightShape.Line || (m_LightShape == LightShape.Rectangle && settings.isRealtime);
 
             using (new EditorGUI.DisabledScope(disabledScope))
             {
                     m_AdditionalLightData.shapeHeight.floatValue = Mathf.Max(m_AdditionalLightData.shapeHeight.floatValue, k_MinAreaWidth);
                     settings.areaSizeX.floatValue = m_AdditionalLightData.shapeWidth.floatValue;
                     settings.areaSizeY.floatValue = m_AdditionalLightData.shapeHeight.floatValue;
-                    settings.shadowsType.enumValueIndex = (int)LightShadows.None;
+                    if (settings.isRealtime)
+                        settings.shadowsType.enumValueIndex = (int)LightShadows.None;
                     break;
 
                 case LightShape.Line:

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/GlobalIlluminationUtils.cs

             ld.color = add.affectDiffuse ? LinearColor.Convert(l.color, l.intensity) : LinearColor.Black();
             ld.indirectColor = add.affectDiffuse ? LightmapperUtils.ExtractIndirect(l) : LinearColor.Black();
 
-            // For HDRP we need to divide the analytic light color by PI (HDRP do explicit PI division for Lambert, but built in Unity and the GI don't)
-            // We apply it on both direct and indirect are they are separated, seems that direct is no used if we used mixed mode with indirect or shadowmask bake.
-            ld.color.red /= Mathf.PI;
-            ld.color.green /= Mathf.PI;
-            ld.color.blue /= Mathf.PI;
-
-            ld.indirectColor.red /= Mathf.PI;
-            ld.indirectColor.green /= Mathf.PI;
-            ld.indirectColor.blue /= Mathf.PI;
-
-#if UNITY_EDITOR
-#else
-            ld.mode = LightMode.Realtime;
-#endif
+
+                // For HDRP we need to divide the analytic light color by PI (HDRP do explicit PI division for Lambert, but built in Unity and the GI don't for punctual lights)
+                // We apply it on both direct and indirect are they are separated, seems that direct is no used if we used mixed mode with indirect or shadowmask bake.
+                ld.color.intensity          /= Mathf.PI;
+                ld.indirectColor.intensity  /= Mathf.PI;
+
                 switch (l.type)
                 {
                     case LightType.Directional:
                 ld.shape1 = 0.0f;
 #endif
                 // TEMP: for now, if we bake a rectangle type this will disable the light for runtime, need to speak with GI team about it!
-                // ld.type = UnityEngine.Experimental.GlobalIllumination.LightType.Rectangle;
-                ld.type = UnityEngine.Experimental.GlobalIllumination.LightType.Point;
+                ld.type = UnityEngine.Experimental.GlobalIllumination.LightType.Rectangle;
-
+                ld.InitNoBake(ld.instanceID);
             }
             else
             {
             for (int i = 0; i < requests.Length; i++)
             {
                 Light l = requests[i];
-                LightDataGIExtract(l, ref ld);
+#if UNITY_EDITOR
+                if (LightmapperUtils.Extract(l.lightmapBakeType) == LightMode.Realtime)
+                    ld.InitNoBake(l.GetInstanceID());
+                else
+                    LightDataGIExtract(l, ref ld);
+#else
+                ld.InitNoBake(l.GetInstanceID());
+#endif
+
                 lightsOutput[i] = ld;
             }
         };