Fixes and improvements to the framework in preparation for the movie recorder.

Core/Editor/RecorderEditor.cs
--------------------------------------------------------------------------------

Fixed input editor foldout functionality.

Core/Editor/RecorderWindow.cs
--------------------------------------------------------------------------------

Now recovering from errors happening when starting a recording session.

Core/Engine/FrameRecorderGOControler.cs
Core/Engine/RecordingSession.cs
Core/Engine/Timeline/FrameRecorderClip.cs
--------------------------------------------------------------------------------

Added visibility control to the frame recorder game object. Callers make it
visible when verbose logging is enabled.

Inputs/CBRenderTexture/Editor/CBRenderTextureInputSettingsEditor.cs
--------------------------------------------------------------------------------

Renamed "Capture alpha" to "Preserve alpha", as agreed with Julien.

Inputs/CBRenderTexture/Engine/CBRenderTextureInput.cs
--------------------------------------------------------------------------------

Made settings public so MediaRecorder can inspect if alpha must be recorded.

Inputs/CBRenderTexture/Shaders/CopyFrameBuffer.shader
--------------------------------------------------------------------------------

Added missing pragma to enable/disable alpha capture.

Recorders/ImageRecorder/Editor/ImageRecorderEditor.cs
--------------------------------------------------------------------------------

Renamed "Video..." recorder category to "Video".

Author: Dominique Leroux

source/FrameRecorder/Core/Editor/RecorderEditor.cs

@@ -6,6 +6,7 @@ namespace UnityEditor.FrameRecorder
     public abstract class RecorderEditor : Editor
     {
         protected SerializedProperty m_Inputs;
+        bool[]             m_ShowInputEditor;
         SerializedProperty m_Verbose;
         SerializedProperty m_FrameRateMode;
         SerializedProperty m_FrameRate;
@@ -23,6 +24,9 @@ protected virtual void OnEnable()
             {
                 var pf = new PropertyFinder<RecorderSettings>(serializedObject);
                 m_Inputs = pf.Find(x => x.m_SourceSettings);
+                m_ShowInputEditor = new bool[m_Inputs.arraySize];
+                for (int i = 0; i < m_ShowInputEditor.Length; ++i)
+                    m_ShowInputEditor[i] = true;
                 m_Verbose = pf.Find(x => x.m_Verbose);
                 m_FrameRateMode = pf.Find(x => x.m_FrameRateMode);
                 m_FrameRate = pf.Find(x => x.m_FrameRate);
@@ -118,12 +122,16 @@ protected virtual void OnInputGui()
                 if (multiInputs)
                 {
                     EditorGUI.indentLevel++;
-                    EditorGUILayout.Foldout(true, "Input " + (i + 1));
+                    m_ShowInputEditor[i] =
+                        EditorGUILayout.Foldout(m_ShowInputEditor[i], "Input " + (i + 1));
                 }
                 var arrItem = m_Inputs.GetArrayElementAtIndex(i);
-                var editor = Editor.CreateEditor( arrItem.objectReferenceValue );
-                if( editor != null)
-                    editor.OnInspectorGUI();
+                if (m_ShowInputEditor[i])
+                {
+                    var editor = Editor.CreateEditor( arrItem.objectReferenceValue );
+                    if (editor)
+                        editor.OnInspectorGUI();
+                }
 
                 if (multiInputs)
                     EditorGUI.indentLevel--;

source/FrameRecorder/Core/Editor/RecorderWindow.cs

@@ -235,7 +235,7 @@ void DelayedStartRecording()
         void StartRecording(bool autoExitPlayMode)
         {
             var settings = (RecorderSettings)m_Editor.target;
-            var go = FrameRecorderGOControler.HookupRecorder();
+            var go = FrameRecorderGOControler.HookupRecorder(!settings.m_Verbose);
             var session = new RecordingSession()
             {
                 m_Recorder = RecordersInventory.GenerateNewRecorder(m_recorderSelector.selectedRecorder, settings),
@@ -246,9 +246,13 @@ void StartRecording(bool autoExitPlayMode)
             component.session = session;
             component.autoExitPlayMode = autoExitPlayMode;
 
-            session.SessionCreated();
-            session.BeginRecording();
-            m_State = EState.Recording;
+            if (session.SessionCreated() && session.BeginRecording())
+                m_State = EState.Recording;
+            else
+            {
+                m_State = EState.Idle;
+                StopRecording();
+            }
         }
 
         void StopRecording()

source/FrameRecorder/Core/Engine/FrameRecorderGOControler.cs

@@ -12,21 +12,25 @@ public class FrameRecorderGOControler
     {
         const string k_HostGoName = "UnityEngine-Recorder-FrameRecorder";
 
-        static GameObject GetGameObject(bool createIfAbsent)
+        static GameObject GetGameObject(bool createIfAbsent, bool hide)
         {
             var go = GameObject.Find(k_HostGoName);
             if (go == null && createIfAbsent)
             {
                 go = new GameObject(k_HostGoName);
+                if (hide)
+                    go.hideFlags = HideFlags.HideInHierarchy;
             }
+
             return go;
         }
 
-        static GameObject GetRecordingSessionsRoot( bool createIfAbsent )
+        static GameObject GetRecordingSessionsRoot(bool createIfAbsent, bool hideGameObjects)
         {
-            var root = GetGameObject(createIfAbsent);
+            var root = GetGameObject(createIfAbsent, hideGameObjects);
             if (root == null)
                 return null;
+
             var settingsTr = root.transform.Find("RecordingSessions");
             GameObject settingsGO;
             if (settingsTr == null)
@@ -40,9 +44,9 @@ static GameObject GetRecordingSessionsRoot( bool createIfAbsent )
             return settingsGO;
         }
 
-        public static GameObject HookupRecorder()
+        public static GameObject HookupRecorder(bool hideGameObjects)
         {
-            var ctrl = GetRecordingSessionsRoot(true);
+            var ctrl = GetRecordingSessionsRoot(true, hideGameObjects);
 
             var recorderGO = new GameObject();
 
@@ -53,7 +57,7 @@ public static GameObject HookupRecorder()
 
         public static GameObject FindRecorder(RecorderSettings settings)
         {
-            var ctrl = GetRecordingSessionsRoot(false);
+            var ctrl = GetRecordingSessionsRoot(false, false);
             if (ctrl == null)
                 return null;
 

source/FrameRecorder/Core/Engine/RecordingSession.cs

@@ -48,13 +48,13 @@ public bool SessionCreated()
         public bool BeginRecording()
         {
             m_RecordingStartTS = (Time.time / Time.timeScale);
+            m_Recorder.SignalInputsOfStage(ERecordingSessionStage.BeginRecording, this);
 
             if (!m_Recorder.BeginRecording(this))
                 return false;
             m_InitialFrame = Time.renderedFrameCount;
             m_FPSTimeStart = Time.unscaledTime;
 
-            m_Recorder.SignalInputsOfStage(ERecordingSessionStage.BeginRecording, this);
             return true;
         }
 

source/FrameRecorder/Core/Engine/Timeline/FrameRecorderClip.cs

@@ -34,7 +34,7 @@ public override Playable CreatePlayable(PlayableGraph graph, GameObject owner)
                 behaviour.session = new RecordingSession()
                 {
                     m_Recorder = RecordersInventory.GenerateNewRecorder(recorderType, m_Settings),
-                    m_RecorderGO = FrameRecorderGOControler.HookupRecorder(),
+                    m_RecorderGO = FrameRecorderGOControler.HookupRecorder(!m_Settings.m_Verbose),
                 };
             }
             return playable;

source/FrameRecorder/Inputs/CBRenderTexture/Editor/CBRenderTextureInputSettingsEditor.cs

@@ -60,7 +60,7 @@ public override void OnInspectorGUI()
                 }
             }
 
-            EditorGUILayout.PropertyField(m_Transparency, new GUIContent("Capture alpha"));
+            EditorGUILayout.PropertyField(m_Transparency, new GUIContent("Preserve alpha"));
             EditorGUILayout.PropertyField(m_FlipVertically, new GUIContent("Flip vertically"));
 
             serializedObject.ApplyModifiedProperties();
@@ -72,4 +72,4 @@ public override void OnInspectorGUI()
 
         }
     }
-}
+}

source/FrameRecorder/Inputs/CBRenderTexture/Engine/CBRenderTextureInput.cs

@@ -20,7 +20,7 @@ public class CBRenderTextureInput : BaseRenderTextureInput
         Camera          m_Camera;
         bool            m_cameraChanged;
 
-        CBRenderTextureInputSettings cbSettings
+        public CBRenderTextureInputSettings cbSettings
         {
             get { return (CBRenderTextureInputSettings)settings; }
         }

source/FrameRecorder/Inputs/CBRenderTexture/Shaders/CopyFrameBuffer.shader

@@ -4,6 +4,7 @@ CGINCLUDE
 #include "UnityCG.cginc"
 #pragma multi_compile ___ UNITY_HDR_ON
 #pragma multi_compile ___ OFFSCREEN
+#pragma multi_compile ___ TRANSPARENCY_ON
 
 sampler2D _TmpFrameBuffer;
 sampler2D _CameraGBufferTexture0;

source/FrameRecorder/Recorders/ImageRecorder/Editor/ImageRecorderEditor.cs

@@ -14,7 +14,7 @@ public class ImagRecorderEditor : RecorderEditor
 
         string[] m_Candidates;
 
-        [MenuItem("Window/Recorder/Video...")]
+        [MenuItem("Window/Recorder/Video")]
         static void ShowRecorderWindow()
         {
             RecorderWindow.ShowAndPreselectCategory("Video");