View difference between Paste ID: NTQ3gXtP and 4B3LHdCi

 #if HAVE_SLATE
 
 using System;
 using System.Collections.Generic;
 
 using UnityEngine;
 
 using Slate;
 
 using Framework.Camera;
 using Framework.Support;
 
 namespace Framework.Cinematics {
 
   /// <summary>Helper methods for dealing with cutscenes</summary>
   public static class CutsceneHelper {
 
     #region class CameraParenter
 
     /// <summary>Temporarily changes the parent of a game object</summary>
     private class CameraParenter : IDisposable {
 
       /// <summary>Initializes a new instance that does nothing</summary>
       public CameraParenter() {
         this.onCutsceneStoppedDelegate = new Action<Cutscene>(onCutsceneStopped);
       }
 
       /// <summary>
       ///   Assigns a new parent to the camera and remembers the previous one
       /// </summary>
       /// <param name="newParentGameObject">New parent for the camera</param>
       /// <param name="cameraGameObject">Camera that will be reparented</param>
       public CameraParenter(
         GameObject newParentGameObject, GameObject cameraGameObject
       ) : this() {
         Initialize(newParentGameObject, cameraGameObject);
       }
 
       /// <summary>
       ///   Assigns a new parent to the camera and remembers the previous one
       /// </summary>
       /// <param name="newParentGameObject">New parent for the camera</param>
       /// <param name="cameraGameObject">Camera that will be reparented</param>
       public void Initialize(
         GameObject newParentGameObject, GameObject cameraGameObject
       ) {
         this.cameraGameObject = cameraGameObject;
 
         Transform cameraTransform = cameraGameObject.transform;
         this.previousPosition = cameraTransform.localPosition;
         this.previousOrientation = cameraTransform.localRotation;
 
         Transform parentTransform = cameraTransform.parent;
         if(parentTransform == null) {
           this.previousParentGameObject = null;
         } else {
           this.previousParentGameObject = parentTransform.gameObject;
         }
 
         GameObjectHelper.SetAsChild(newParentGameObject, cameraGameObject);
         cameraTransform.localPosition = Vector3.zero;
         cameraTransform.localRotation = Quaternion.identity;
       }
 
       /// <summary>Restores the original parent of the camera</summary>
       public void Dispose() {
         WatchCutsceneForRecycling(null);
 
         if(this.cameraGameObject != null) {
           GameObjectHelper.SetAsChild(this.previousParentGameObject, this.cameraGameObject);
 
           Transform cameraTransform = this.cameraGameObject.transform;
           cameraTransform.localPosition = this.previousPosition;
           cameraTransform.localRotation = this.previousOrientation;
 
           this.cameraGameObject = null;
         }
       }
 
       /// <summary>Sets the parenter up for recycling after a cutscene finishes</summary>
       /// <param name="cutscene">Cutscene that will be watched for completion</param>
       public void WatchCutsceneForRecycling(Cutscene cutscene) {
         if(this.cutsceneForUnsubscribe != null) {
           Cutscene.OnCutsceneStopped -= this.onCutsceneStoppedDelegate;
           this.cutsceneForUnsubscribe = null;
         }
         if(cutscene != null) {
           Cutscene.OnCutsceneStopped += this.onCutsceneStoppedDelegate;
           this.cutsceneForUnsubscribe = cutscene;
         }
       }
 
       /// <summary>Recycles the parenter when the cutscene stops playing</summary>
       /// <param name="cutscene">Cutscene that has stopped playing</param>
       private void onCutsceneStopped(Cutscene cutscene) {
         if(ReferenceEquals(this.cutsceneForUnsubscribe, cutscene)) {
           Dispose();
 
           CutsceneHelper.recyclableCameraParenters.Add(this);
         }
       }
 
       /// <summary>Game object that will be reparented</summary>
       private GameObject cameraGameObject;
       /// <summary>Game object that was the camera's previous parent</summary>
       private GameObject previousParentGameObject;
       /// <summary>Previous position of the camera</summary>
       private Vector3 previousPosition;
       /// <summary>Previous orientation of the camera</summary>
       private Quaternion previousOrientation;
 
       /// <summary>Cutscene this camera parenter is watching for completion</summary>
       private Cutscene cutsceneForUnsubscribe;
       /// <summary>Delegate for the onCutsceneStopped() method</summary>
       private Action<Cutscene> onCutsceneStoppedDelegate;
 
     }
 
     #endregion // class CameraParenter
 
     /// <summary>Starts playing a cutscene using the specified camera</summary>
     /// <param name="cutscene">Cutscene that will be played</param>
     /// <param name="camera">Camera on which the cutscene will be played</param>
     /// <param name="callback">Callback to invoke when the cutscene ends</param>
     public static void PlayCutsceneOnCamera(
       Cutscene cutscene, UnityEngine.Camera camera, System.Action callback = null
     ) {
 
       // Stop the DirectorCamera from messing with our camera settings
       DirectorCamera.setMainWhenActive = false;
-      DirectorCamera.matchMainCamera = False;
+      DirectorCamera.matchMainCamera = false;
       DirectorCamera.autoHandleActiveState = false;
       DirectorCamera.dontDestroyOnLoad = false;
 
       // Parent our render camera to the director camera root
       CameraParenter parenter = recycleOrCreateCameraParenter();
       parenter.Initialize(DirectorCamera.current.gameObject, camera.gameObject);
 
       // Set up the parenter to recycle (and unparent) when the cutscene ends,
       // then play the cutscene (in this order in case of a zero-length cutscene)
       parenter.WatchCutsceneForRecycling(cutscene);
 
       // Start the cutscene. This will disable the active camera, but we'll undo
       // that little mishap right away
       cutscene.Play(0.0f, callback);
 
       // Switch to our own render camera
       CameraHelper.ActivateCamera(camera);
     }
 
     /// <summary>Starts playing a cutscene using the director camera</summary>
     /// <param name="cutscene">Cutscene that will be played</param>
     /// <param name="camera">Camera that will be active when the cutscene starts</param>
     /// <param name="callback">Callback to invoke when the cutscene ends</param>
     public static void PlayCutsceneOnDirectorCamera(
       Cutscene cutscene, UnityEngine.Camera camera, System.Action callback = null
     ) {
 
       // In this mode, we want the DirectorCamera to copy the camera's settings
-      // In this case, we want the director camera to take over all camera settings
+
       DirectorCamera.matchMainCamera = true;
       DirectorCamera.autoHandleActiveState = true;
       DirectorCamera.dontDestroyOnLoad = false;
 
       // Active the camera from which the DirectorCamera should copy its settings
       CameraHelper.ActivateCamera(camera);
 
       // Start the cutscene
       cutscene.Play(0.0f, callback);
 
     }
 
     /// <summary>
     ///   Returns a recycled instance of a camera parenter or creates a new one
     /// </summary>
     /// <returns>An unused instance of a camera parenter</returns>
     private static CameraParenter recycleOrCreateCameraParenter() {
       if(recyclableCameraParenters == null) {
         recyclableCameraParenters = new List<CameraParenter>();
         return new CameraParenter();
       }
 
       int parenterCount = recyclableCameraParenters.Count;
       if(parenterCount == 0) {
         return new CameraParenter();
       }
 
       CameraParenter parenter = recyclableCameraParenters[parenterCount - 1];
       recyclableCameraParenters.RemoveAt(parenterCount - 1);
       return parenter;
     }
 
     /// <summary>Camera parenters that are ready for reuse</summary>
     private static IList<CameraParenter> recyclableCameraParenters;
 
   }
 
 } // namespace Framework.Cinematics
 
 #endif // HAVE_SLATE