/// <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; } }