Added camera inspector for lightweight pipeline.

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetEditor.cs

             public static GUIContent defaultShader = new GUIContent("Default Shader",
                 "Shader to use when creating materials");
 
-            public static GUIContent msaaContent = new GUIContent("Anti Aliasing (MSAA)", "Controls the global anti aliasing quality. When set to disabled, MSAA will not be performed even if the camera allows it.");
+            public static GUIContent msaaContent = new GUIContent("Anti Aliasing (MSAA)", "Controls the global anti aliasing applied to all cameras.");
+
+            public static GUIContent msaaDisabledWarning = new GUIContent("MSAA is not supported when Soft Particles are enabled.");
         }
 
         private int kMaxSupportedAdditionalPixelLights = 8;
             EditorGUILayout.PropertyField(m_SupportsVertexLightProp, Styles.enableVertexLightLabel);
             EditorGUILayout.PropertyField(m_SupportSoftParticlesProp, Styles.enableSoftParticles);
             EditorGUILayout.PropertyField(m_MSAA, Styles.msaaContent);
+
+            if (m_SupportSoftParticlesProp.boolValue && m_MSAA.intValue > 1)
+                EditorGUILayout.HelpBox(Styles.msaaDisabledWarning.text, MessageType.Warning);
+
             EditorGUI.indentLevel--;
             EditorGUILayout.Space();
             EditorGUILayout.Space();

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

             }
             // When post process or soft particles are enabled we disable msaa due to lack of depth resolve
             // One can still use PostFX AA
-            else if (m_CurrCamera.allowMSAA && m_Asset.MSAASampleCount > 1)
+            else if (m_Asset.MSAASampleCount > 1)
             {
                 configuration |= FrameRenderingConfiguration.Msaa;
                 intermediateTexture = !LightweightUtils.PlatformSupportsMSAABackBuffer();
             float renderScale = (m_CurrCamera.cameraType == CameraType.Game) ? m_Asset.RenderScale : 1.0f;
             int rtWidth = (int)((float)m_CurrCamera.pixelWidth * renderScale);
             int rtHeight = (int)((float)m_CurrCamera.pixelHeight * renderScale);
-            int msaaSamples = (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.Msaa)) ? m_Asset.MSAASampleCount : 1;
+            int msaaSamples = (m_IsOffscreenCamera) ? Math.Min(m_CurrCamera.targetTexture.antiAliasing, m_Asset.MSAASampleCount) : m_Asset.MSAASampleCount;
+            msaaSamples = (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.Msaa)) ? msaaSamples : 1;
 
             if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.IntermediateTexture))
             {

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightCameraEditor.cs

+using System;
+using UnityEditor.AnimatedValues;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Scripting;
+using UnityEditor.Modules;
+using UnityEngine.Experimental.Rendering.LightweightPipeline;
+using UnityEngine.Rendering.PostProcessing;
+
+namespace UnityEditor
+{
+    [CustomEditorForRenderPipeline(typeof(Camera), typeof(LightweightPipelineAsset))]
+    [CanEditMultipleObjects]
+    public class LightweightameraEditor : Editor
+    {
+        // Manually entered rendering path names/values, since we want to show them
+        // in different order than they appear in the enum.
+        private static readonly GUIContent[] kCameraRenderPaths =
+        {
+            new GUIContent("Use Graphics Settings"),
+            new GUIContent("Forward"),
+            new GUIContent("Deferred"),
+            new GUIContent("Legacy Vertex Lit"),
+            new GUIContent("Legacy Deferred (light prepass)")
+        };
+
+        private static readonly int[] kCameraRenderPathValues =
+        {
+            (int) RenderingPath.UsePlayerSettings,
+            (int) RenderingPath.Forward,
+            (int) RenderingPath.DeferredShading,
+            (int) RenderingPath.VertexLit,
+            (int) RenderingPath.DeferredLighting
+        };
+
+        public class Styles
+        {
+            public readonly GUIContent renderingPathWarning = new GUIContent("Lightweight Pipeline only supports Forward rendering path.");
+            public readonly GUIContent clipingPlanesLabel = new GUIContent("Clipping Planes", "Distances from the camera to start and stop rendering.");
+            public readonly GUIContent nearPlaneLabel = new GUIContent("Near", "The closest point relative to the camera that drawing will occur.");
+            public readonly GUIContent farPlaneLabel = new GUIContent("Far", "The furthest point relative to the camera that drawing will occur.");
+            public readonly GUIContent fixNow = new GUIContent("Fix now");
+        };
+
+        private static Styles s_Styles;
+        private LightweightPipelineAsset lightweightPipeline;
+        private PostProcessLayer postProcessLayer;
+
+        public SerializedProperty clearFlags { get; private set; }
+        public SerializedProperty backgroundColor { get; private set; }
+        public SerializedProperty normalizedViewPortRect { get; private set; }
+        public SerializedProperty fieldOfView { get; private set; }
+        public SerializedProperty orthographic { get; private set; }
+        public SerializedProperty orthographicSize { get; private set; }
+        public SerializedProperty depth { get; private set; }
+        public SerializedProperty cullingMask { get; private set; }
+        public SerializedProperty renderingPath { get; private set; }
+        public SerializedProperty occlusionCulling { get; private set; }
+        public SerializedProperty targetTexture { get; private set; }
+        public SerializedProperty HDR { get; private set; }
+        public SerializedProperty allowMSAA { get; private set; }
+        public SerializedProperty allowDynamicResolution { get; private set; }
+        public SerializedProperty stereoConvergence { get; private set; }
+        public SerializedProperty stereoSeparation { get; private set; }
+        public SerializedProperty nearClippingPlane { get; private set; }
+        public SerializedProperty farClippingPlane { get; private set; }
+
+
+#if ENABLE_MULTIPLE_DISPLAYS
+        public SerializedProperty targetDisplay { get; private set; }
+#endif
+
+        public SerializedProperty targetEye { get; private set; }
+
+        private Camera camera { get { return target as Camera; } }
+
+        // Animation Properties
+        private bool IsSameClearFlags { get { return !clearFlags.hasMultipleDifferentValues; } }
+        private bool IsSameOrthographic { get { return !orthographic.hasMultipleDifferentValues; } }
+        private bool IsSameRenderingPath { get { return !renderingPath.hasMultipleDifferentValues; } }
+
+        private bool ShowRenderingPathWarning { get { return IsSameRenderingPath && renderingPath.intValue != (int)RenderingPath.Forward; } }
+
+        readonly AnimBool showBGColorAnim = new AnimBool();
+        readonly AnimBool showOrthoAnim = new AnimBool();
+        readonly AnimBool showTargetEyeAnim = new AnimBool();
+
+        void SetAnimationTarget(AnimBool anim, bool initialize, bool targetValue)
+        {
+            if (initialize)
+            {
+                anim.value = targetValue;
+                anim.valueChanged.AddListener(Repaint);
+            }
+            else
+            {
+                anim.target = targetValue;
+            }
+        }
+
+        void UpdateAnimationValues(bool initialize)
+        {
+            SetAnimationTarget(showBGColorAnim, initialize, IsSameClearFlags && (camera.clearFlags == CameraClearFlags.SolidColor || camera.clearFlags == CameraClearFlags.Skybox));
+            SetAnimationTarget(showOrthoAnim, initialize, IsSameOrthographic && camera.orthographic);
+            SetAnimationTarget(showTargetEyeAnim, initialize, targetEye.intValue != (int)StereoTargetEyeMask.Both || PlayerSettings.virtualRealitySupported);
+        }
+
+        private static readonly GUIContent[] kTargetEyes =
+        {
+            new GUIContent("Both"),
+            new GUIContent("Left"),
+            new GUIContent("Right"),
+            new GUIContent("None (Main Display)"),
+        };
+
+        private static readonly int[] kTargetEyeValues =
+        {
+            (int) StereoTargetEyeMask.Both, (int) StereoTargetEyeMask.Left,
+            (int) StereoTargetEyeMask.Right, (int) StereoTargetEyeMask.None
+        };
+
+        void OnEnable()
+        {
+            lightweightPipeline = GraphicsSettings.renderPipelineAsset as LightweightPipelineAsset;
+            postProcessLayer = camera.GetComponent<PostProcessLayer>();
+
+            clearFlags = serializedObject.FindProperty("m_ClearFlags");
+            backgroundColor = serializedObject.FindProperty("m_BackGroundColor");
+            normalizedViewPortRect = serializedObject.FindProperty("m_NormalizedViewPortRect");
+            nearClippingPlane = serializedObject.FindProperty("near clip plane");
+            farClippingPlane = serializedObject.FindProperty("far clip plane");
+            fieldOfView = serializedObject.FindProperty("field of view");
+            orthographic = serializedObject.FindProperty("orthographic");
+            orthographicSize = serializedObject.FindProperty("orthographic size");
+            depth = serializedObject.FindProperty("m_Depth");
+            cullingMask = serializedObject.FindProperty("m_CullingMask");
+            renderingPath = serializedObject.FindProperty("m_RenderingPath");
+            occlusionCulling = serializedObject.FindProperty("m_OcclusionCulling");
+            targetTexture = serializedObject.FindProperty("m_TargetTexture");
+            HDR = serializedObject.FindProperty("m_HDR");
+            allowMSAA = serializedObject.FindProperty("m_AllowMSAA");
+            allowDynamicResolution = serializedObject.FindProperty("m_AllowDynamicResolution");
+
+            stereoConvergence = serializedObject.FindProperty("m_StereoConvergence");
+            stereoSeparation = serializedObject.FindProperty("m_StereoSeparation");
+
+#if ENABLE_MULTIPLE_DISPLAYS
+            targetDisplay = serializedObject.FindProperty("m_TargetDisplay");
+#endif
+
+            targetEye = serializedObject.FindProperty("m_TargetEye");
+
+            UpdateAnimationValues(true);
+        }
+
+        void OnDisable()
+        {
+            showBGColorAnim.valueChanged.RemoveListener(Repaint);
+            showOrthoAnim.valueChanged.RemoveListener(Repaint);
+            showTargetEyeAnim.valueChanged.RemoveListener(Repaint);
+
+            lightweightPipeline = null;
+        }
+
+        public void DrawClearFlags()
+        {
+            EditorGUILayout.PropertyField(clearFlags,
+                new GUIContent(
+                    "Clear Flags","What to display in empty areas of this Camera's view.\n\nChoose Skybox to display a skybox in empty areas, defaulting to a background color if no skybox is found.\n\nChoose Solid Color to display a background color in empty areas.\n\nChoose Depth Only to display nothing in empty areas.\n\nChoose Don't Clear to display whatever was displayed in the previous frame in empty areas."));
+        }
+
+        public void DrawBackgroundColor()
+        {
+            EditorGUILayout.PropertyField(backgroundColor,
+                new GUIContent("Background", "The Camera clears the screen to this color before rendering."));
+        }
+
+        public void DrawCullingMask()
+        {
+            EditorGUILayout.PropertyField(cullingMask);
+        }
+
+        public void DrawProjection()
+        {
+            ProjectionType projectionType = orthographic.boolValue
+                ? ProjectionType.Orthographic
+                : ProjectionType.Perspective;
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.showMixedValue = orthographic.hasMultipleDifferentValues;
+            projectionType =
+                (ProjectionType)
+                EditorGUILayout.EnumPopup(
+                    new GUIContent(
+                        "Projection", "How the Camera renders perspective.\n\nChoose Perspective to render objects with perspective.\n\nChoose Orthographic to render objects uniformly, with no sense of perspective."),
+                    projectionType);
+            EditorGUI.showMixedValue = false;
+            if (EditorGUI.EndChangeCheck())
+                orthographic.boolValue = (projectionType == ProjectionType.Orthographic);
+
+            if (!orthographic.hasMultipleDifferentValues)
+            {
+                if (projectionType == ProjectionType.Orthographic)
+                    EditorGUILayout.PropertyField(orthographicSize, new GUIContent("Size"));
+                else
+                    EditorGUILayout.Slider(fieldOfView, 1f, 179f,
+                        new GUIContent(
+                            "Field of View", "The width of the Camera’s view angle, measured in degrees along the local Y axis."));
+            }
+        }
+
+        public void DrawClippingPlanes()
+        {
+            EditorGUILayout.LabelField(s_Styles.clipingPlanesLabel);
+            EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(nearClippingPlane, s_Styles.nearPlaneLabel);
+            EditorGUILayout.PropertyField(farClippingPlane, s_Styles.farPlaneLabel);
+            EditorGUI.indentLevel--;
+        }
+
+        public void DrawNormalizedViewPorts()
+        {
+            EditorGUILayout.PropertyField(normalizedViewPortRect,
+                new GUIContent("Viewport Rect", "Four values that indicate where on the screen this camera view will be drawn. Measured in Viewport Coordinates (values 0–1)."));
+        }
+
+        public void DrawDepth()
+        {
+            EditorGUILayout.PropertyField(depth);
+        }
+
+        public void DrawRenderingPath()
+        {
+            EditorGUILayout.IntPopup(renderingPath, kCameraRenderPaths, kCameraRenderPathValues,
+                new GUIContent("Rendering Path"));
+
+            if (ShowRenderingPathWarning)
+            {
+                EditorGUILayout.HelpBox(s_Styles.renderingPathWarning.text, MessageType.Warning);
+
+                // Button (align lower right)
+                if (GUI.Button(new Rect(0.0f, 0.0f, 60.0f, 20.0f), s_Styles.fixNow))
+                    renderingPath.intValue = (int) RenderingPath.Forward;
+            }
+        }
+
+        public void DrawTargetTexture()
+        {
+            EditorGUILayout.PropertyField(targetTexture);
+
+            // show warning if we have deferred but manual MSAA set
+            // only do this if the m_TargetTexture has the same values across all target cameras
+
+            // TODO: Add fix to change target texture msaa
+            if (!targetTexture.hasMultipleDifferentValues)
+            {
+                var texture = targetTexture.objectReferenceValue as RenderTexture;
+
+                // Lightweight pipeline forces MSAA off when postprocessing or softparticles are enabled
+                bool postProcessEnabled = postProcessLayer != null && postProcessLayer.enabled;
+                bool msaaDisable = postProcessEnabled || lightweightPipeline.SupportsSoftParticles;
+                int pipelineSamplesCount = (msaaDisable) ? 1 : lightweightPipeline.MSAASampleCount;
+
+                if (texture && texture.antiAliasing > pipelineSamplesCount)
+                {
+                    string pipelineMSAACaps = (pipelineSamplesCount > 1)
+                        ? String.Format("is set to support {0}x", pipelineSamplesCount)
+                        : "has MSAA disabled";
+                    if (postProcessEnabled)
+                        pipelineMSAACaps += " due to this camera having a post process effect enabled";
+                    else if (lightweightPipeline.SupportsSoftParticles)
+                        pipelineMSAACaps += " due to Soft Particles being enabled in the pipeline asset";
+                    EditorGUILayout.HelpBox(String.Format("Camera target texture requires {0}x MSAA. Lightweight pipeline {1}.", texture.antiAliasing, pipelineMSAACaps),
+                        MessageType.Warning, true);
+                }
+            }
+        }
+
+        public void DrawOcclusionCulling()
+        {
+            EditorGUILayout.PropertyField(occlusionCulling);
+        }
+
+        public void DrawHDR()
+        {
+            EditorGUILayout.PropertyField(HDR, new GUIContent("Allow HDR"));
+        }
+
+        public void DrawMSAA()
+        {
+            EditorGUILayout.PropertyField(allowMSAA);
+        }
+
+        public void DrawDynamicResolution()
+        {
+            EditorGUILayout.PropertyField(allowDynamicResolution);
+        }
+
+        public void DrawVR()
+        {
+            if (PlayerSettings.virtualRealitySupported)
+            {
+                EditorGUILayout.PropertyField(stereoSeparation);
+                EditorGUILayout.PropertyField(stereoConvergence);
+            }
+        }
+
+        // Not supported ATM
+//        public void DrawMultiDisplay()
+//        {
+//#if ENABLE_MULTIPLE_DISPLAYS
+//            if (ModuleManager.ShouldShowMultiDisplayOption())
+//            {
+//                int prevDisplay = targetDisplay.intValue;
+//                EditorGUILayout.Space();
+//                EditorGUILayout.IntPopup(targetDisplay, DisplayUtility.GetDisplayNames(),
+//                    DisplayUtility.GetDisplayIndices(), EditorGUIUtility.TempContent("Target Display"));
+//                if (prevDisplay != targetDisplay.intValue)
+//                    GameView.RepaintAll();
+//            }
+//#endif
+//        }
+
+        public void DrawTargetEye()
+        {
+            EditorGUILayout.IntPopup(targetEye, kTargetEyes, kTargetEyeValues, new GUIContent("Target Eye"));
+        }
+
+        enum ProjectionType
+        {
+            Perspective,
+            Orthographic
+        };
+
+        public override void OnInspectorGUI()
+        {
+            if (s_Styles == null)
+                s_Styles = new Styles();
+
+            serializedObject.Update();
+            UpdateAnimationValues(false);
+
+            DrawClearFlags();
+
+            using (var group = new EditorGUILayout.FadeGroupScope(showBGColorAnim.faded))
+                if (group.visible) DrawBackgroundColor();
+
+            DrawCullingMask();
+
+            EditorGUILayout.Space();
+
+            DrawProjection();
+
+            DrawClippingPlanes();
+
+            DrawNormalizedViewPorts();
+
+            EditorGUILayout.Space();
+            DrawDepth();
+            DrawRenderingPath();
+            DrawTargetTexture();
+            DrawOcclusionCulling();
+            DrawHDR();
+            DrawVR();
+
+            using (var group = new EditorGUILayout.FadeGroupScope(showTargetEyeAnim.faded))
+                if (group.visible) DrawTargetEye();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightCameraEditor.cs.meta

+fileFormatVersion: 2
+guid: d569aa2a3d2a1a74aaf68c388f2e0798
+timeCreated: 1509983694
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: