Cita de: lightbug date=1554238898El método "AlignAuxiliaryCameraWithViewport" está haciendo cosas como:
   
   

GameObject[] newSelection = new GameObject[1] { auxiliaryCamera.gameObject };

   
      probablemente estés generando cuadro a cuadro más basura que homero simpson como alcalde https://docs.unity3d.com/ScriptReference/EditorWindow.OnSelectionChange.html )una vez ocurre esto moves la cámara (que previamente catcheaste) a la posición correcta.
   
   
      Y el AlignObjectWithView (dedicado a la mainCamera) lo unico que hace es algo así:
   
   

if( viewportCamera == null )
viewportCamera = SceneView.GetAllSceneCameras()[0];
   
if( mainCamera == null )
mainCamera = Camera.main;            
   
mainCamera.transform.position = viewportCamera.transform.position;
mainCamera.transform.rotation = viewportCamera.transform.rotation;

   
      En tiempo real funciona, aunque no recuerdo si lo usé en un OnSceneGUI, Update (con [ExecuteInEditMode] ) o parecido, la verdad ya borré todo xD, osea sería una variante en tiempo real de "AlignObjectWithView", pero no es lo mismo que lo que aparece en el video.
   

using UnityEngine;
public class PointOfViewHandler: MonoBehaviour
{
    [Header("")]
#pragma warning disable IDE0044 // Add readonly modifier
    [SerializeField] private new Transform camera;
    [Header("References of points of view")]
    // Assigned in inspector
    [SerializeField] private Transform firstPerson = null;
    [SerializeField] private Transform thirdPerson = null;
    public enum PointsOfView
    {
        FIRST_PERSON,
        THIRD_PERSON
    }
    [Header("")]
    [SerializeField] private PointsOfView currentPointOfView = PointsOfView.FIRST_PERSON;
    [Header("Lerp parameters")]
    [SerializeField] private float lerpTime = 25;
    [SerializeField] private AnimationCurve smoothCurve = new AnimationCurve( new Keyframe[]{ new Keyframe( 0, 0 ) , new Keyframe( 1, 1 ) } );
#pragma warning restore IDE0044 // Add readonly modifier
    private float currentLerpTime;
    private Transform target;
    private void Awake()
    {
        GetCamera();
        SetInitialPosition();
    }
    private void GetCamera()
    {
        if ( camera == null )
            try { camera = Camera.main.transform; }
            catch
            {
                try { camera = FindObjectOfType<Camera>().transform; }
                catch { Debug.LogError( "Assign a camera" ); }
            }
        camera.transform.SetParent( transform );
        camera.transform.localPosition = Vector3.zero;
        camera.transform.localRotation = Quaternion.identity;
    }
    private void SetInitialPosition()
    {
        if ( firstPerson == null || thirdPerson == null )
        {
            Debug.LogError( "Point of view not assigned" );
            return;
        }
        switch ( currentPointOfView )
        {
            case PointsOfView.FIRST_PERSON:
                transform.position = firstPerson.position;
                transform.rotation = firstPerson.rotation;
                break;
            case PointsOfView.THIRD_PERSON:
                transform.position = thirdPerson.position;
                transform.rotation = thirdPerson.rotation;
                break;
        }
    }
    private void Update()
    {
        if ( Input.GetKeyDown( KeyCode.V ) )
            ChangePoint();
        if ( target == null ) return;
        if ( Vector3.Distance( transform.position, target.position ) < 0.01f )
        {
            transform.position = target.position;
        }
        Movement();
    }
    private void Movement()
    {
        if ( target == null ) return;
        currentLerpTime += Time.deltaTime;
        float percent = smoothCurve.Evaluate(currentLerpTime / lerpTime);
        Translate( percent );
        Rotate( percent );
    }
    private void Translate( float percent ) => transform.position = Vector3.Lerp( transform.position, target.position, percent );
    private void Rotate( float percent ) => transform.rotation = Quaternion.Lerp( transform.rotation, target.rotation, percent );
    private void ChangePoint()
    {
        currentLerpTime = 0f;
        currentPointOfView = currentPointOfView == PointsOfView.FIRST_PERSON ? PointsOfView.THIRD_PERSON : PointsOfView.FIRST_PERSON;
        switch ( currentPointOfView )
        {
            case PointsOfView.FIRST_PERSON:
                target = firstPerson;
                break;
            case PointsOfView.THIRD_PERSON:
                target = thirdPerson;
                break;
        }
    }
}

using Unit***itor;
using UnityEngine;
public class ViewportSceneCameraManager: EditorWindow
{
    private static Camera auxiliaryCamera;
    private RenderTexture renderTexture;
    [MenuItem( "Test/Create viewport scene camera" )]
    private static void Init()
    {
        EditorWindow editorWindow = GetWindow( typeof( ViewportSceneCameraManager ) );
        editorWindow.autoRepaintOnSceneChange = true;
        editorWindow.Show();
    }
    public void Awake()
    {
        renderTexture = new RenderTexture( (int)position.width,
            (int)position.height,
            (int)RenderTextureFormat.ARGB32 );
    }
    public void OnEnable()
    {
        CreateAuxiliaryCamera();
    }
    public void Update()
    {
        AlignAuxiliaryCameraWithViewport();
        if ( auxiliaryCamera != null )
        {
            auxiliaryCamera.targetTexture = renderTexture;
            auxiliaryCamera.Render();
            auxiliaryCamera.targetTexture = null;
        }
        if ( renderTexture.width != position.width ||
            renderTexture.height != position.height )
            renderTexture = new RenderTexture( (int)position.width,
                (int)position.height,
                (int)RenderTextureFormat.ARGB32 );
    }
    private void OnGUI()
    {
        if ( renderTexture )
            GUI.DrawTexture( new Rect( 0.0f, 0.0f, position.width, position.height ), renderTexture );
    }
    private static void CreateAuxiliaryCamera()
    {
        GameObject camObj = Instantiate(Camera.main.gameObject);
        camObj.name = "Debug Camera";
        Component[] camComponents = camObj.GetComponents<Component>();
        for ( int i = 0; i < camComponents.Length; i++ )
        {
            if ( camComponents[i].GetType() != typeof( Camera ) && camComponents[i].GetType() != typeof( Transform ) )
            {
                if ( BL.DebugManager.DebugManager.isEditorMode )
                    DestroyImmediate( camComponents[i] );
                else
                    Destroy( camComponents[i] );
            }
        }
        auxiliaryCamera = camObj.GetComponent<Camera>();
        auxiliaryCamera.clearFlags = CameraClearFlags.SolidColor;
        auxiliaryCamera.depth = -100;
    }
    private static void AlignAuxiliaryCameraWithViewport()
    {
        Object[] backupSelections = null;
        if ( Selection.objects != null )
            backupSelections = Selection.objects;
        GameObject[] newSelection = new GameObject[1] { auxiliaryCamera.gameObject };
        Selection.objects = newSelection;
        EditorApplication.ExecuteMenuItem( "GameObject/Align With View" );
        if ( backupSelections == null )
            Selection.objects = new Object[0];
        Selection.objects = backupSelections;
    }
    private void OnDestroy()
    {
        if ( isEditorMode )
            DestroyImmediate( auxiliaryCamera.gameObject );
        else
            Destroy( auxiliaryCamera.gameObject );
    }
    public static bool isEditor => Application.platform == RuntimePlatform.OSXEditor || Application.platform == RuntimePlatform.WindowsEditor || Application.platform == RuntimePlatform.LinuxEditor;
    public static bool isEditorMode => isEditor && !Application.isPlaying;
}