Added the possibility to export the currently rendered sky to a Texture2D and then to an EXR.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

 using UnityEditor;
 using UnityEngine.SceneManagement;
 using UnityEngine.Experimental.Rendering.HDPipeline;
+using System.IO;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
                     LayeredLitGUI.SetupMaterialKeywordsAndPass(mat);
                     EditorUtility.SetDirty(mat);
                 }
+            }
+        }
+
+        [MenuItem("HDRenderPipeline/Export Sky to Image")]
+        static void ExportSkyToImage()
+        {
+            HDRenderPipelineInstance renderpipelineInstance = UnityEngine.Experimental.Rendering.RenderPipelineManager.currentPipeline as HDRenderPipelineInstance;
+            if(renderpipelineInstance == null)
+            {
+                Debug.LogError("HDRenderPipeline is not instantiated.");
+                return;
+            }
+
+            Texture2D result = renderpipelineInstance.ExportSkyToTexture();
+            if(result == null)
+            {
+                Debug.LogError("Cannot export sky to an image, Sky is not setup properly.");
+                return;
+            }
+
+            // Encode texture into PNG
+            byte[] bytes = null;
+            bytes = result.EncodeToEXR(Texture2D.EXRFlags.CompressZIP);
+            Object.DestroyImmediate(result);
+
+            string assetPath = EditorUtility.SaveFilePanel("Export Sky", "Assets", "SkyExport", "exr");
+            if (!string.IsNullOrEmpty(assetPath))
+            {
+                File.WriteAllBytes(assetPath, bytes);
+                AssetDatabase.Refresh();
             }
         }
     }

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             m_SkyManager.RenderSky(hdCamera, m_LightLoop == null ? null : m_LightLoop.GetCurrentSunLight(), m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, renderContext);
         }
 
+        public Texture2D ExportSkyToTexture()
+        {
+            return m_SkyManager.ExportSkyToImage();
+        }
+
         void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, bool renderOpaque)
         {
             // TODO: Currently we can't render opaque object forward when deferred is enabled

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/SkyManager.cs

                 }
             }
         }
+
+        public Texture2D ExportSkyToImage()
+        {
+            if(m_Renderer != null && m_Renderer.IsSkyValid())
+            {
+                int resolution = (int)m_SkySettings.resolution;
+
+                RenderTexture tempRT = new RenderTexture(resolution * 6, resolution, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
+                tempRT.dimension = TextureDimension.Tex2D;
+                tempRT.useMipMap = false;
+                tempRT.autoGenerateMips = false;
+                tempRT.filterMode = FilterMode.Trilinear;
+                tempRT.Create();
+
+                Texture2D temp = new Texture2D(resolution * 6, resolution, TextureFormat.RGBAFloat, false);
+                Texture2D result = new Texture2D(resolution * 6, resolution, TextureFormat.RGBAFloat, false);
+
+                // Note: We need to invert in Y the cubemap faces because the current sky cubemap is inverted (because it's a RT)
+                // So to invert it again so that it's a proper cubemap image we need to do it in several steps because ReadPixels does not have scale parameters:
+                // - Convert the cubemap into a 2D texture
+                // - Blit and invert it to a temporary target.
+                // - Read this target again into the result texture.
+                int offset = 0;
+                for (int i = 0; i < 6; ++i)
+                {
+                    Graphics.SetRenderTarget(m_SkyboxCubemapRT, 0, (CubemapFace)i);
+                    temp.ReadPixels(new Rect(0, 0, resolution, resolution), offset, 0);
+                    temp.Apply();
+                    offset += resolution;
+                }
+
+                Graphics.Blit(temp, tempRT, new Vector2(1.0f, -1.0f), new Vector2(0.0f, 0.0f));
+
+                result.ReadPixels(new Rect(0, 0, resolution * 6, resolution), 0, 0);
+                result.Apply();
+
+                Graphics.SetRenderTarget(null);
+                Object.DestroyImmediate(temp);
+                Object.DestroyImmediate(tempRT);
+
+                return result;
+            }
+            else
+            {
+                return null;
+            }
+        }
     }
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/Utilities.cs

             HDRenderPipeline renderContext = GraphicsSettings.renderPipelineAsset as HDRenderPipeline;
             if (renderContext == null)
             {
-                Debug.LogWarning("SkyParameters component can only be used with HDRenderPipeline custom RenderPipeline.");
+                Debug.LogWarning("HDRenderPipeline is not instantiated.");
                 return null;
             }