Game/Entity/CameraViewSystem.cs

Local component that decides which remote cameras the player can view and swaps the main camera's render filters and post-process state while a remote view is active. It rebuilds a per-frame list of viewable cameras, checks seat access on linked contraptions, and handles press/hold and toggle bindings.

/// <summary>
/// Local viewing state. A camera never switches another player's main view.
/// A loose camera answers only its owner's binding, from anywhere. A camera linked to a
/// contraption with a seat answers whoever is sitting in one of its seats, and nobody else.
/// </summary>
[Hide]
public sealed class CameraViewSystem : Component, Global.ISaveEvents
{
	const string BodyTag = "remote_camera_body";
	readonly Dictionary<string, bool> _down = new( StringComparer.OrdinalIgnoreCase );
	// Rebuilt at the start of each input pass; the view pass later in the frame reads it.
	readonly HashSet<CameraEntity> _viewable = new();
	readonly Dictionary<GameObject, bool?> _seatAccess = new();
	readonly LinkedGameObjectBuilder _linked = new();
	readonly HashSet<BaseChair> _linkedChairs = new();
	CameraComponent _mainCamera;
	bool _hadViewmodel, _hadFirstperson, _hadViewer;
	CameraComponent.Axis _originalAxis;
	IDisposable _inputHook;
	public CameraEntity ActiveCamera { get; private set; }

	public static CameraViewSystem Get( Scene scene ) => scene.IsValid() ? scene.Get<CameraViewSystem>() : null;

	public static CameraViewSystem GetOrCreate( Scene scene )
	{
		if ( Get( scene ) is { } existing ) return existing;
		// A local component can also be installed in a game already running during hotload.
		using ( scene.Push() )
		{
			var go = new GameObject( true, "Camera view controller" );
			go.Flags |= GameObjectFlags.NotSaved | GameObjectFlags.NotNetworked;
			return go.AddComponent<CameraViewSystem>();
		}
	}

	bool CanView( CameraEntity camera ) => camera.IsValid() && camera.Active && camera.Scene == Scene && _viewable.Contains( camera );

	void RefreshViewable( Player player )
	{
		_viewable.Clear();
		_seatAccess.Clear();
		var localSeat = player.GetComponentInParent<BaseChair>( false );
		foreach ( var camera in Scene.GetAllComponents<CameraEntity>() )
		{
			if ( !camera.IsValid() || !camera.Active ) continue;
			var root = camera.GameObject.Root;
			if ( !_seatAccess.TryGetValue( root, out var seatAccess ) )
			{
				seatAccess = ResolveSeatAccess( camera.GameObject, localSeat );
				foreach ( var linked in _linked.Objects ) _seatAccess[linked] = seatAccess;
				_seatAccess[root] = seatAccess;
				_linked.Clear();
			}
			// No seat on the contraption: the owner's global bind. Otherwise: only from its seats.
			if ( seatAccess ?? camera.IsLocallyOwned ) _viewable.Add( camera );
		}
	}

	/// <summary>Null when nothing linked has a seat, otherwise whether the local player sits in one of them.</summary>
	bool? ResolveSeatAccess( GameObject source, BaseChair localSeat )
	{
		_linked.Clear();
		_linkedChairs.Clear();
		_linked.AddConnected( source );
		foreach ( var obj in _linked.Objects )
			foreach ( var chair in obj.GetComponentsInChildren<BaseChair>() )
				_linkedChairs.Add( chair );
		if ( _linkedChairs.Count == 0 ) return null;
		var seated = localSeat.IsValid() && _linkedChairs.Contains( localSeat );
		_linkedChairs.Clear();
		return seated;
	}

	protected override void OnEnabled() => RegisterInputHook();

	protected override void OnUpdate()
	{
		// Install the hook for controllers that already existed when this code hotloaded.
		if ( _inputHook is null ) RegisterInputHook();
	}

	void RegisterInputHook()
	{
		_inputHook?.Dispose();
		_inputHook = Scene.AddHook( GameObjectSystem.Stage.StartUpdate, -100, UpdateInput, nameof( CameraViewSystem ), "Camera view bindings" );
	}

	void UpdateInput()
	{
		if ( Scene != Game.ActiveScene ) return;
		var player = Player.FindLocalPlayer();
		// Leave before freecam applies its own render filters later in this frame.
		if ( !player.IsValid() || player.Health <= 0 || Input.Keyboard.Pressed( "J" ) || Scene.Get<FreeCamGameObjectSystem>().IsActive )
		{
			_viewable.Clear();
			Clear();
			_down.Clear();
			return;
		}

		// Leaving the seat drops a contraption camera here, ending the view below.
		RefreshViewable( player );
		if ( ActiveCamera is not null && (!CanView( ActiveCamera ) || !ActiveCamera.ViewInput.IsEnabled) ) Clear();

		var actions = Input.GetActions().Select( a => a.Name ).ToHashSet( StringComparer.OrdinalIgnoreCase );
		var groups = Scene.GetAllComponents<CameraEntity>().Where( c => CanView( c ) && c.ViewInput.IsEnabled )
			.GroupBy( c => c.ViewInput.HasKey ? c.ViewInput.Key : c.ViewInput.Action, StringComparer.OrdinalIgnoreCase ).ToArray();
		// A raw key always works; an action has to still exist in this game.
		bool IsBound( IGrouping<string, CameraEntity> g ) => g.First().ViewInput.HasKey || actions.Contains( g.Key );
		var bound = groups.Where( IsBound ).Select( g => g.Key ).ToHashSet( StringComparer.OrdinalIgnoreCase );
		foreach ( var stale in _down.Keys.Where( key => !bound.Contains( key ) ).ToArray() ) _down.Remove( stale );
		foreach ( var group in groups )
		{
			if ( !bound.Contains( group.Key ) )
			{
				if ( ActiveCamera.IsValid() && group.Contains( ActiveCamera ) ) Clear();
				continue;
			}
			// Process a binding only once, even if several cameras use it. An active
			// camera gets first refusal so the next toggle can always leave its view.
			var target = ActiveCamera.IsValid() && group.Contains( ActiveCamera ) ? ActiveCamera : group.OrderBy( c => c.ViewOrder ).Last();
			var input = target.ViewInput;
			bool down = input.LocalDown();
			bool pressed = target.ToggleMode ? input.LocalPressed() : down && !_down.GetValueOrDefault( group.Key );
			_down[group.Key] = down;
			ProcessInput( target, down, pressed );
			// A bound camera owns Change View; don't also flip first/third person,
			// especially when releasing a hold-to-view camera.
			if ( !input.HasKey && string.Equals( group.Key, player.Controller.ToggleCameraModeButton, StringComparison.OrdinalIgnoreCase ) )
				Input.Clear( group.Key );
		}
	}

	void StopInputHook()
	{
		_inputHook?.Dispose();
		_inputHook = null;
		Clear();
	}

	protected override void OnDisabled() => StopInputHook();
	protected override void OnDestroy() => StopInputHook();

	// The next camera pass reapplies the active view. Persist only the normal camera's
	// filters, otherwise a save made while watching could restore hidden viewmodels.
	void Global.ISaveEvents.BeforeSave( string filename ) => RestoreCameraTags();
	void Global.ISaveEvents.BeforeLoad( string filename ) => Clear();

	internal void ProcessInput( CameraEntity camera, bool down, bool pressed )
	{
		if ( !CanView( camera ) ) return;
		if ( camera.ToggleMode )
		{
			if ( pressed )
			{
				if ( ActiveCamera == camera ) Clear();
				else SetActive( camera );
			}
		}
		else if ( pressed && down ) SetActive( camera );
		else if ( !down && ActiveCamera == camera ) Clear();
	}

	public void SetActive( CameraEntity camera )
	{
		if ( !CanView( camera ) || camera == ActiveCamera ) return;
		Clear();
		ActiveCamera = camera;
	}

	public void Release( CameraEntity camera )
	{
		if ( ActiveCamera == camera ) Clear();
	}

	public void Clear()
	{
		if ( ActiveCamera.IsValid() )
		{
			foreach ( var model in ActiveCamera.GetComponentsInChildren<ModelRenderer>( true ) )
				if ( model.SceneObject.IsValid() ) model.SceneObject.Tags.Remove( BodyTag );
		}
		ActiveCamera = null;
		RestoreCameraTags();
	}

	void RestoreCameraTags()
	{
		if ( _mainCamera.IsValid() )
		{
			_mainCamera.RenderExcludeTags.Set( "viewmodel", _hadViewmodel );
			_mainCamera.RenderExcludeTags.Set( "firstperson", _hadFirstperson );
			_mainCamera.RenderExcludeTags.Set( "viewer", _hadViewer );
			_mainCamera.RenderExcludeTags.Remove( BodyTag );
			_mainCamera.FovAxis = _originalAxis;
		}
		_mainCamera = null;

		// back to the player's own effects
		_viewEffects.Clear();
		if ( Scene.GetSystem<PostProcessManager>() is { } effects )
			effects.Suppressed = false;
	}

	readonly CameraEffectStack _viewEffects = new();

	internal void ApplyView( CameraEntity entity, CameraComponent camera, ref CameraView view )
	{
		if ( entity != ActiveCamera || !CanView( entity ) ) return;

		if ( CameraEffectSystem.Get( Scene ) is { } effects )
			effects.Scale = 0f;

		if ( _mainCamera != camera )
		{
			RestoreCameraTags();
			_mainCamera = camera;
			_hadViewmodel = camera.RenderExcludeTags.Has( "viewmodel" );
			_hadFirstperson = camera.RenderExcludeTags.Has( "firstperson" );
			_hadViewer = camera.RenderExcludeTags.Has( "viewer" );
			_originalAxis = camera.FovAxis;
		}
		foreach ( var model in entity.GetComponentsInChildren<ModelRenderer>( true ) )
			if ( model.SceneObject.IsValid() ) model.SceneObject.Tags.Add( BodyTag );
		camera.RenderExcludeTags.Add( BodyTag );
		camera.RenderExcludeTags.Add( "viewmodel" );
		camera.RenderExcludeTags.Add( "firstperson" );
		camera.RenderExcludeTags.Remove( "viewer" );
		camera.FovAxis = CameraComponent.Axis.Horizontal;

		// the camera's own effects, not the player's, so looking through matches its displays
		if ( Scene.GetSystem<PostProcessManager>() is { } playerEffects )
			playerEffects.Suppressed = true;
		_viewEffects.Apply( camera.GameObject, entity );

		view.Position = entity.ViewTransform.Position;
		view.Rotation = entity.ViewTransform.Rotation;
		view.FieldOfView = entity.ViewFov;
		view.ZNear = entity.Feed?.Camera?.ZNear ?? 1f;
	}
}