/// <summary>Applies the axis values and orients the camera accordingly</summary>
/// <param name="curState">The current camera state</param>
/// <param name="deltaTime">Used for calculating damping. Not used.</param>
public override void MutateCameraState(ref CameraState curState, float deltaTime)
{
if (!IsValid)
return;
// Only read joystick when game is playing
if (deltaTime >= 0 && CinemachineCore.Instance.IsLive(VirtualCamera))
{
if (m_HorizontalAxis.Update(deltaTime))
m_HorizontalRecentering.CancelRecentering();
if (m_VerticalAxis.Update(deltaTime))
m_VerticalRecentering.CancelRecentering();
var recenterTarget = GetRecenterTarget();
m_HorizontalRecentering.DoRecentering(ref m_HorizontalAxis, deltaTime, recenterTarget.x);
m_VerticalRecentering.DoRecentering(ref m_VerticalAxis, deltaTime, recenterTarget.y);
}
// If we have a transform parent, then apply POV in the local space of the parent
Quaternion rot = Quaternion.Euler(m_VerticalAxis.Value, m_HorizontalAxis.Value, 0);
Transform parent = VirtualCamera.transform.parent;
if (parent != null)
rot = parent.rotation * rot;
else
rot = rot * Quaternion.FromToRotation(Vector3.up, curState.ReferenceUp);
curState.RawOrientation = rot;
}
/// <summary>If we are transitioning from another FreeLook, grab the axis values from it.</summary>
/// <param name="fromCam">The camera being deactivated. May be null.</param>
/// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
/// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
public override void OnTransitionFromCamera(
ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
{
base.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
InvokeOnTransitionInExtensions(fromCam, worldUp, deltaTime);
bool forceUpdate = false;
m_RecenterToTargetHeading.DoRecentering(ref m_XAxis, -1, 0);
m_RecenterToTargetHeading.DoRecentering(ref m_YAxis, -1, 0.5f);
m_RecenterToTargetHeading.CancelRecentering();
m_YAxis.m_Recentering.CancelRecentering();
if (fromCam != null && m_Transitions.m_InheritPosition)
{
var cameraPos = fromCam.State.RawPosition;
// Special handling for FreeLook: get an undamped outgoing position
if (fromCam is CinemachineFreeLook)
{
var flFrom = (fromCam as CinemachineFreeLook);
var orbital = flFrom.mOrbitals != null ? flFrom.mOrbitals[1] : null;
if (orbital != null)
{
cameraPos = orbital.GetTargetCameraPosition(worldUp);
}
}
UpdateRigCache();
if (m_BindingMode != CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp)
{
m_XAxis.Value = mOrbitals[1].GetAxisClosestValue(cameraPos, worldUp);
}
m_YAxis.Value = GetYAxisClosestValue(cameraPos, worldUp);
transform.position = cameraPos;
transform.rotation = fromCam.State.RawOrientation;
m_State = PullStateFromVirtualCamera(worldUp, ref m_Lens);
PreviousStateIsValid = false;
PushSettingsToRigs();
forceUpdate = true;
}
if (forceUpdate)
{
InternalUpdateCameraState(worldUp, deltaTime);
}
else
{
UpdateCameraState(worldUp, deltaTime);
}
if (m_Transitions.m_OnCameraLive != null)
{
m_Transitions.m_OnCameraLive.Invoke(this, fromCam);
}
}
/// <summary>
/// Update the X axis and calculate the heading. This can be called by a delegate
/// with a custom axis.
/// <param name="deltaTime">Used for damping. If less than 0, no damping is done.</param>
/// <param name="up">World Up, set by the CinemachineBrain</param>
/// <param name="axis"></param>
/// <param name="recentering"></param>
/// <param name="isLive"/>true if the vcam is live</param>
/// <returns>Axis value</returns>
/// </summary>
public float UpdateHeading(
float deltaTime, Vector3 up, ref AxisState axis,
ref AxisState.Recentering recentering, bool isLive)
{
if (m_BindingMode == BindingMode.SimpleFollowWithWorldUp)
{
axis.m_MinValue = -180;
axis.m_MaxValue = 180;
}
// Only read joystick when game is playing
if (deltaTime < 0 || !VirtualCamera.PreviousStateIsValid || !isLive)
{
axis.Reset();
recentering.CancelRecentering();
}
else if (axis.Update(deltaTime))
{
recentering.CancelRecentering();
}
if (m_BindingMode == BindingMode.SimpleFollowWithWorldUp)
{
float finalHeading = axis.Value;
axis.Value = 0;
return(finalHeading);
}
float targetHeading = GetTargetHeading(axis.Value, GetReferenceOrientation(up));
recentering.DoRecentering(ref axis, deltaTime, targetHeading);
return(axis.Value);
}
private CameraState CalculateNewState(Vector3 worldUp, float deltaTime)
{
CameraState state = PullStateFromVirtualCamera(worldUp, ref m_Lens);
m_YAxisRecentering.DoRecentering(ref m_YAxis, deltaTime, 0.5f);
// Blend from the appropriate rigs
float t = GetYAxisValue();
if (t > 0.5f)
{
if (mBlendA != null)
{
mBlendA.TimeInBlend = (t - 0.5f) * 2f;
mBlendA.UpdateCameraState(worldUp, deltaTime);
state = mBlendA.State;
}
}
else
{
if (mBlendB != null)
{
mBlendB.TimeInBlend = t * 2f;
mBlendB.UpdateCameraState(worldUp, deltaTime);
state = mBlendB.State;
}
}
return(state);
}
/// <summary>Applies the axis values and orients the camera accordingly</summary>
/// <param name="curState">The current camera state</param>
/// <param name="deltaTime">Used for calculating damping. Not used.</param>
public override void MutateCameraState(ref CameraState curState, float deltaTime)
{
if (!IsValid)
{
return;
}
// Only read joystick when game is playing
if (deltaTime >= 0 || CinemachineCore.Instance.IsLive(VirtualCamera))
{
if (m_HorizontalAxis.Update(deltaTime))
{
m_HorizontalRecentering.CancelRecentering();
}
if (m_VerticalAxis.Update(deltaTime))
{
m_VerticalRecentering.CancelRecentering();
}
}
m_HorizontalRecentering.DoRecentering(ref m_HorizontalAxis, deltaTime, 0);
m_VerticalRecentering.DoRecentering(ref m_VerticalAxis, deltaTime, 0);
Quaternion rot = Quaternion.Euler(m_VerticalAxis.Value, m_HorizontalAxis.Value, 0);
rot = rot * Quaternion.FromToRotation(Vector3.up, curState.ReferenceUp);
curState.RawOrientation = rot;
}
/// <summary>
/// Update the X axis and calculate the heading. This can be called by a delegate
/// with a custom axis.
/// <param name="deltaTime">Used for damping. If less than 0, no damping is done.</param>
/// <param name="up">World Up, set by the CinemachineBrain</param>
/// <param name="axis"></param>
/// <returns>Axis value</returns>
/// </summary>
public float UpdateHeading(float deltaTime, Vector3 up, ref AxisState axis)
{
// Only read joystick when game is playing
if (deltaTime < 0 || !CinemachineCore.Instance.IsLive(VirtualCamera))
{
axis.Reset();
m_RecenterToTargetHeading.CancelRecentering();
}
else if (axis.Update(deltaTime))
{
m_RecenterToTargetHeading.CancelRecentering();
}
float targetHeading = GetTargetHeading(axis.Value, GetReferenceOrientation(up), deltaTime);
if (m_BindingMode != BindingMode.SimpleFollowWithWorldUp)
{
m_RecenterToTargetHeading.DoRecentering(ref axis, deltaTime, targetHeading);
}
float finalHeading = axis.Value;
if (m_BindingMode == BindingMode.SimpleFollowWithWorldUp)
{
axis.Value = 0;
}
return(finalHeading);
}
private CameraState CalculateNewState(Vector3 worldUp, float deltaTime, Vector3 preCameraPos)
{
CameraState state = PullStateFromVirtualCamera(worldUp, ref m_Lens);
m_YAxisLimit.DoAxisLimit(ref m_YAxis, new Vector3(0, 1, 0), true, m_Lens.FieldOfView);
float recenterTarget = GetYRecenterTarget(preCameraPos);
m_YAxisRecentering.DoRecentering(ref m_YAxis, deltaTime, recenterTarget);
// Blend from the appropriate rigs
float t = GetYAxisValue();
if (t > 0.5f)
{
if (mBlendA != null)
{
mBlendA.TimeInBlend = (t - 0.5f) * 2f;
mBlendA.UpdateCameraState(worldUp, deltaTime);
state = mBlendA.State;
}
}
else
{
if (mBlendB != null)
{
mBlendB.TimeInBlend = t * 2f;
mBlendB.UpdateCameraState(worldUp, deltaTime);
state = mBlendB.State;
}
}
return(state);
}
private CameraState CalculateNewState(Vector3 worldUp, float deltaTime)
{
//UnityEngine.Profiling.Profiler.BeginSample("CinemachineFreeLook.CalculateNewState");
CameraState state = PullStateFromVirtualCamera(worldUp, m_Lens);
m_Lens = state.Lens;
m_YAxisRecentering.DoRecentering(ref m_YAxis, deltaTime, 0.5f);
// Blend from the appropriate rigs
float t = GetYAxisValue();
if (t > 0.5f)
{
if (mBlendA != null)
{
mBlendA.TimeInBlend = (t - 0.5f) * 2f;
mBlendA.UpdateCameraState(worldUp, deltaTime);
state = mBlendA.State;
}
}
else
{
if (mBlendB != null)
{
mBlendB.TimeInBlend = t * 2f;
mBlendB.UpdateCameraState(worldUp, deltaTime);
state = mBlendB.State;
}
}
//UnityEngine.Profiling.Profiler.EndSample();
return(state);
}
/// <summary>
/// Update the X axis and calculate the heading. This can be called by a delegate
/// with a custom axis.
/// <param name="deltaTime">Used for damping. If less than 0, no damping is done.</param>
/// <param name="up">World Up, set by the CinemachineBrain</param>
/// <param name="axis"></param>
/// <param name="recentering"></param>
/// <param name="isLive"/>true if the vcam is live</param>
/// <returns>Axis value</returns>
/// </summary>
public float UpdateHeading(
float deltaTime, Vector3 up, ref AxisState axis,
ref AxisState.Recentering recentering, bool isLive)
{
// Only read joystick when game is playing
if (deltaTime < 0 || !isLive)
{
axis.Reset();
recentering.CancelRecentering();
}
else if (axis.Update(deltaTime))
{
recentering.CancelRecentering();
}
float targetHeading = GetTargetHeading(axis.Value, GetReferenceOrientation(up), deltaTime);
if (deltaTime >= 0 && m_BindingMode != BindingMode.SimpleFollowWithWorldUp)
{
recentering.DoRecentering(ref axis, deltaTime, targetHeading);
}
float finalHeading = axis.Value;
if (m_BindingMode == BindingMode.SimpleFollowWithWorldUp)
{
axis.Value = 0;
}
return(finalHeading);
}
/// <summary>Notification that this virtual camera is going live.
/// Base class implementation does nothing.</summary>
/// <param name="fromCam">The camera being deactivated. May be null.</param>
/// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
/// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
/// <returns>True if the vcam should do an internal update as a result of this call</returns>
public override bool OnTransitionFromCamera(
ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime,
ref CinemachineVirtualCameraBase.TransitionParams transitionParams)
{
m_RecenterToTargetHeading.DoRecentering(ref m_XAxis, -1, 0);
m_RecenterToTargetHeading.CancelRecentering();
if (fromCam != null && //&& fromCam.Follow == FollowTarget
m_BindingMode != CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp &&
transitionParams.m_InheritPosition)
{
m_XAxis.Value = GetAxisClosestValue(fromCam.State.RawPosition, worldUp);
return(true);
}
return(false);
}
protected override void PostPipelineStageCallback(
CinemachineVirtualCameraBase vcam,
CinemachineCore.Stage stage, ref CameraState state, float deltaTime)
{
if (stage == m_ApplyAfter)
{
// Only read joystick when game is playing
if (m_UpdateAlways || (deltaTime >= 0 && CinemachineCore.Instance.IsLive(VirtualCamera)))
{
bool changed = m_HorizontalInput.Update(deltaTime, ref m_HorizontalAxis);
if (m_VerticalInput.Update(deltaTime, ref m_VerticalAxis))
{
changed = true;
}
if (changed)
{
m_HorizontalRecentering.CancelRecentering();
m_VerticalRecentering.CancelRecentering();
}
}
m_HorizontalAxis.m_Value = m_HorizontalRecentering.DoRecentering(m_HorizontalAxis.m_Value, deltaTime, 0);
m_VerticalAxis.m_Value = m_VerticalRecentering.DoRecentering(m_VerticalAxis.m_Value, deltaTime, 0);
// If we have a transform parent, then apply POV in the local space of the parent
Quaternion rot = Quaternion.Euler(m_VerticalAxis.m_Value, m_HorizontalAxis.m_Value, 0);
Transform parent = VirtualCamera.transform.parent;
if (parent != null)
{
rot = parent.rotation * rot;
}
else
{
rot = rot * Quaternion.FromToRotation(Vector3.up, state.ReferenceUp);
}
state.RawOrientation = rot;
}
}
