internal static void DrawVirtualCameraBaseGizmos(CinemachineVirtualCameraBase vcam, GizmoType selectionType) { // Don't draw gizmos on hidden stuff if ((vcam.VirtualCameraGameObject.hideFlags & (HideFlags.HideInHierarchy | HideFlags.HideInInspector)) != 0) { return; } if (vcam.ParentCamera != null && (selectionType & GizmoType.Active) == 0) { return; } CameraState state = vcam.State; Gizmos.DrawIcon(state.FinalPosition, kGizmoFileName, true); DrawCameraFrustumGizmo( CinemachineCore.Instance.FindPotentialTargetBrain(vcam), state.Lens, Matrix4x4.TRS( state.FinalPosition, UnityQuaternionExtensions.Normalized(state.FinalOrientation), Vector3.one), CinemachineCore.Instance.IsLive(vcam) ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour); }
/// <summary>Applies the composer rules and orients the camera accordingly</summary> /// <param name="curState">The current camera state</param> /// <param name="statePrevFrame">The camera state on the previous frame (unused)</param> /// <param name="deltaTime">Used for calculating damping. If less than /// or equal to zero, then target will snap to the center of the dead zone.</param> /// <returns>curState with RawOrientation applied</returns> public virtual CameraState MutateCameraState( CameraState curState, CameraState statePrevFrame, float deltaTime) { if (!IsValid || !curState.HasLookAt) { return(curState); } CameraState newState = curState; newState.ReferenceLookAt = GetTrackedPoint(ref newState); float targetDistance = (newState.ReferenceLookAt - newState.CorrectedPosition).magnitude; if (targetDistance < UnityVectorExtensions.Epsilon) { return(newState); // navel-gazing, get outa here } // Calculate effective fov - fake it for ortho based on target distance float fov, fovH; if (newState.Lens.Orthographic) { fov = Mathf.Rad2Deg * 2 * Mathf.Atan(newState.Lens.OrthographicSize / targetDistance); fovH = Mathf.Rad2Deg * 2 * Mathf.Atan(newState.Lens.Aspect * newState.Lens.OrthographicSize / targetDistance); } else { fov = newState.Lens.FieldOfView; double radHFOV = 2 * Math.Atan(Math.Tan(fov * Mathf.Deg2Rad / 2) * newState.Lens.Aspect); fovH = (float)(Mathf.Rad2Deg * radHFOV); } Rect softGuideFOV = ScreenToFOV(SoftGuideRect, fov, fovH, newState.Lens.Aspect); if (deltaTime <= 0) { // No damping, just snap to central bounds, skipping the soft zone Rect rect = new Rect(softGuideFOV.center, Vector2.zero); // Force to center newState.RawOrientation = PlaceWithinScreenBounds( ref newState, rect, newState.RawOrientation, fov, fovH, 0); } else { // Start with previous frame's orientation (but with current up) Quaternion rigOrientation = Quaternion.LookRotation( statePrevFrame.RawOrientation * Vector3.forward, newState.ReferenceUp); // First force the previous rotation into the hard bounds, no damping Rect hardGuideFOV = ScreenToFOV(HardGuideRect, fov, fovH, newState.Lens.Aspect); newState.RawOrientation = PlaceWithinScreenBounds( ref newState, hardGuideFOV, rigOrientation, fov, fovH, 0); // Now move it through the soft zone, with damping newState.RawOrientation = PlaceWithinScreenBounds( ref newState, softGuideFOV, newState.RawOrientation, fov, fovH, deltaTime); } newState.RawOrientation = UnityQuaternionExtensions.Normalized(newState.RawOrientation); return(newState); }
/// <summary>Applies the composer rules and orients the camera accordingly</summary> /// <param name="curState">The current camera state</param> /// <param name="statePrevFrame">The camera state on the previous frame (unused)</param> /// <param name="deltaTime">Used for calculating damping. If less than /// or equal to zero, then target will snap to the center of the dead zone.</param> /// <returns>curState with RawOrientation applied</returns> public CameraState MutateCameraState( CameraState curState, CameraState statePrevFrame, float deltaTime) { if (!IsValid || !curState.HasLookAt) { return(curState); } CameraState newState = curState; newState.ReferenceLookAt = GetTrackedPoint(newState.ReferenceLookAt); if ((newState.ReferenceLookAt - newState.CorrectedPosition).AlmostZero()) { return(newState); // navel-gazing, get outa here } CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(VirtualCamera); float aspect = brain != null ? brain.OutputCamera.aspect : 1; float fovH = CameraUtilities.CalculateHorizontalFOV(newState.Lens.FieldOfView, aspect); Rect softGuideFOV = ScreenToFOV(SoftGuideRect, newState.Lens.FieldOfView, fovH, aspect); if (deltaTime <= 0) { // No damping, just snap to central bounds, skipping the soft zone Rect rect = new Rect(softGuideFOV.center, Vector2.zero); // Force to center newState.RawOrientation = PlaceWithinScreenBounds( ref newState, rect, newState.RawOrientation, fovH, 0); } else { // Start with previous frame's orientation (but with current up) Quaternion rigOrientation = Quaternion.LookRotation( statePrevFrame.RawOrientation * Vector3.forward, newState.ReferenceUp); // First force the previous rotation into the hard bounds, no damping Rect hardGuideFOV = ScreenToFOV(HardGuideRect, newState.Lens.FieldOfView, fovH, aspect); newState.RawOrientation = PlaceWithinScreenBounds( ref newState, hardGuideFOV, rigOrientation, fovH, 0); // Now move it through the soft zone, with damping newState.RawOrientation = PlaceWithinScreenBounds( ref newState, softGuideFOV, newState.RawOrientation, fovH, deltaTime); } newState.RawOrientation = UnityQuaternionExtensions.Normalized(newState.RawOrientation); return(newState); }
internal static void DrawVirtualCameraGizmos(CinemachineVirtualCameraBase vcam, GizmoType selectionType) { // Don't draw gizmos on hidden stuff if ((vcam.VirtualCameraGameObject.hideFlags & (HideFlags.HideInHierarchy | HideFlags.HideInInspector)) != 0) { return; } Color originalGizmoColour = Gizmos.color; Gizmos.color = CinemachineCore.Instance.IsLive(vcam) ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour; CameraState state = vcam.State; Gizmos.DrawIcon(state.FinalPosition, "Cinemachine/cm_logo_lg.png", true); float aspect = 1; CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(vcam); if (brain != null) { aspect = brain.OutputCamera.aspect; } Matrix4x4 originalMatrix = Gizmos.matrix; Gizmos.matrix = Matrix4x4.TRS( state.FinalPosition, UnityQuaternionExtensions.Normalized(state.FinalOrientation), Vector3.one); Gizmos.DrawFrustum( Vector3.zero, state.Lens.FieldOfView, state.Lens.FarClipPlane, state.Lens.NearClipPlane, aspect); Gizmos.matrix = originalMatrix; Gizmos.color = originalGizmoColour; }
/// <summary>Intelligently blend the contents of two states.</summary> /// <param name="stateA">The first state, corresponding to t=0</param> /// <param name="stateB">The second state, corresponding to t=1</param> /// <param name="t">How much to interpolate. Internally clamped to 0..1</param> /// <returns>Linearly interpolated CameraState</returns> public static CameraState Lerp(CameraState stateA, CameraState stateB, float t) { t = Mathf.Clamp01(t); float adjustedT = t; CameraState state = new CameraState(); // Combine the blend hints intelligently if (((stateA.BlendHint & stateB.BlendHint) & BlendHintValue.NoPosition) != 0) { state.BlendHint |= BlendHintValue.NoPosition; } if (((stateA.BlendHint & stateB.BlendHint) & BlendHintValue.NoOrientation) != 0) { state.BlendHint |= BlendHintValue.NoOrientation; } if (((stateA.BlendHint & stateB.BlendHint) & BlendHintValue.NoLens) != 0) { state.BlendHint |= BlendHintValue.NoLens; } if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.SphericalPositionBlend) != 0) { state.BlendHint |= BlendHintValue.SphericalPositionBlend; } if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.CylindricalPositionBlend) != 0) { state.BlendHint |= BlendHintValue.CylindricalPositionBlend; } if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.NoLens) == 0) { state.Lens = LensSettings.Lerp(stateA.Lens, stateB.Lens, t); } else if (((stateA.BlendHint & stateB.BlendHint) & BlendHintValue.NoLens) == 0) { if ((stateA.BlendHint & BlendHintValue.NoLens) != 0) { state.Lens = stateB.Lens; } else { state.Lens = stateA.Lens; } } state.ReferenceUp = Vector3.Slerp(stateA.ReferenceUp, stateB.ReferenceUp, t); state.ShotQuality = Mathf.Lerp(stateA.ShotQuality, stateB.ShotQuality, t); state.PositionCorrection = ApplyPosBlendHint( stateA.PositionCorrection, stateA.BlendHint, stateB.PositionCorrection, stateB.BlendHint, state.PositionCorrection, Vector3.Lerp(stateA.PositionCorrection, stateB.PositionCorrection, t)); state.OrientationCorrection = ApplyRotBlendHint( stateA.OrientationCorrection, stateA.BlendHint, stateB.OrientationCorrection, stateB.BlendHint, state.OrientationCorrection, Quaternion.Slerp(stateA.OrientationCorrection, stateB.OrientationCorrection, t)); // LookAt target if (!stateA.HasLookAt || !stateB.HasLookAt) { state.ReferenceLookAt = kNoPoint; } else { // Re-interpolate FOV to preserve target composition, if possible float fovA = stateA.Lens.FieldOfView; float fovB = stateB.Lens.FieldOfView; if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.NoLens) == 0 && !state.Lens.Orthographic && !Mathf.Approximately(fovA, fovB)) { LensSettings lens = state.Lens; lens.FieldOfView = InterpolateFOV( fovA, fovB, Mathf.Max((stateA.ReferenceLookAt - stateA.CorrectedPosition).magnitude, stateA.Lens.NearClipPlane), Mathf.Max((stateB.ReferenceLookAt - stateB.CorrectedPosition).magnitude, stateB.Lens.NearClipPlane), t); state.Lens = lens; // Make sure we preserve the screen composition through FOV changes adjustedT = Mathf.Abs((lens.FieldOfView - fovA) / (fovB - fovA)); } // Linear interpolation of lookAt target point state.ReferenceLookAt = Vector3.Lerp( stateA.ReferenceLookAt, stateB.ReferenceLookAt, adjustedT); } // Raw position state.RawPosition = ApplyPosBlendHint( stateA.RawPosition, stateA.BlendHint, stateB.RawPosition, stateB.BlendHint, state.RawPosition, state.InterpolatePosition( stateA.RawPosition, stateA.ReferenceLookAt, stateB.RawPosition, stateB.ReferenceLookAt, t)); // Interpolate the LookAt in Screen Space if requested if (state.HasLookAt && ((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.RadialAimBlend) != 0) { state.ReferenceLookAt = state.RawPosition + Vector3.Slerp( stateA.ReferenceLookAt - state.RawPosition, stateB.ReferenceLookAt - state.RawPosition, adjustedT); } // Clever orientation interpolation Quaternion newOrient = state.RawOrientation; if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.NoOrientation) == 0) { Vector3 dirTarget = Vector3.zero; if (state.HasLookAt)//&& ((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.RadialAimBlend) == 0) { // If orientations are different, use LookAt to blend them float angle = Quaternion.Angle(stateA.RawOrientation, stateB.RawOrientation); if (angle > UnityVectorExtensions.Epsilon) { dirTarget = state.ReferenceLookAt - state.CorrectedPosition; } } if (dirTarget.AlmostZero() || ((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.IgnoreLookAtTarget) != 0) { // Don't know what we're looking at - can only slerp newOrient = UnityQuaternionExtensions.SlerpWithReferenceUp( stateA.RawOrientation, stateB.RawOrientation, t, state.ReferenceUp); } else { // Rotate while preserving our lookAt target dirTarget = dirTarget.normalized; if ((dirTarget - state.ReferenceUp).AlmostZero() || (dirTarget + state.ReferenceUp).AlmostZero()) { // Looking up or down at the pole newOrient = UnityQuaternionExtensions.SlerpWithReferenceUp( stateA.RawOrientation, stateB.RawOrientation, t, state.ReferenceUp); } else { // Put the target in the center newOrient = Quaternion.LookRotation(dirTarget, state.ReferenceUp); // Blend the desired offsets from center Vector2 deltaA = -stateA.RawOrientation.GetCameraRotationToTarget( stateA.ReferenceLookAt - stateA.CorrectedPosition, stateA.ReferenceUp); Vector2 deltaB = -stateB.RawOrientation.GetCameraRotationToTarget( stateB.ReferenceLookAt - stateB.CorrectedPosition, stateB.ReferenceUp); newOrient = newOrient.ApplyCameraRotation( Vector2.Lerp(deltaA, deltaB, adjustedT), state.ReferenceUp); } } } state.RawOrientation = ApplyRotBlendHint( stateA.RawOrientation, stateA.BlendHint, stateB.RawOrientation, stateB.BlendHint, state.RawOrientation, newOrient); // Accumulate the custom blendables and apply the weights for (int i = 0; i < stateA.NumCustomBlendables; ++i) { CustomBlendable b = stateA.GetCustomBlendable(i); b.m_Weight *= (1 - t); if (b.m_Weight > UnityVectorExtensions.Epsilon) { state.AddCustomBlendable(b); } } for (int i = 0; i < stateB.NumCustomBlendables; ++i) { CustomBlendable b = stateB.GetCustomBlendable(i); b.m_Weight *= t; if (b.m_Weight > UnityVectorExtensions.Epsilon) { state.AddCustomBlendable(b); } } return(state); }
/// <summary>Applies the composer rules and orients the camera accordingly</summary> /// <param name="curState">The current camera state</param> /// <param name="deltaTime">Used for calculating damping. If less than /// zero, then target will snap to the center of the dead zone.</param> public override void MutateCameraState(ref CameraState curState, float deltaTime) { if (!IsValid || !curState.HasLookAt) { return; } // Correct the tracked point in the event that it's behind the camera // while the real target is in front if (!(TrackedPoint - curState.ReferenceLookAt).AlmostZero()) { Vector3 mid = Vector3.Lerp(curState.CorrectedPosition, curState.ReferenceLookAt, 0.5f); Vector3 toLookAt = curState.ReferenceLookAt - mid; Vector3 toTracked = TrackedPoint - mid; if (Vector3.Dot(toLookAt, toTracked) < 0) { float t = Vector3.Distance(curState.ReferenceLookAt, mid) / Vector3.Distance(curState.ReferenceLookAt, TrackedPoint); TrackedPoint = Vector3.Lerp(curState.ReferenceLookAt, TrackedPoint, t); } } float targetDistance = (TrackedPoint - curState.CorrectedPosition).magnitude; if (targetDistance < Epsilon) { if (deltaTime >= 0 && VirtualCamera.PreviousStateIsValid) { curState.RawOrientation = m_CameraOrientationPrevFrame; } return; // navel-gazing, get outa here } // Expensive FOV calculations mCache.UpdateCache(curState.Lens, SoftGuideRect, HardGuideRect, targetDistance); Quaternion rigOrientation = curState.RawOrientation; if (deltaTime < 0 || !VirtualCamera.PreviousStateIsValid) { // No damping, just snap to central bounds, skipping the soft zone rigOrientation = Quaternion.LookRotation( rigOrientation * Vector3.forward, curState.ReferenceUp); Rect rect = mCache.mFovSoftGuideRect; if (m_CenterOnActivate) { rect = new Rect(rect.center, Vector2.zero); // Force to center } RotateToScreenBounds( ref curState, rect, curState.ReferenceLookAt, ref rigOrientation, mCache.mFov, mCache.mFovH, -1); } else { // Start with previous frame's orientation (but with current up) Vector3 dir = m_LookAtPrevFrame - m_CameraPosPrevFrame; if (dir.AlmostZero()) { rigOrientation = Quaternion.LookRotation( m_CameraOrientationPrevFrame * Vector3.forward, curState.ReferenceUp); } else { dir = Quaternion.Euler(curState.PositionDampingBypass) * dir; rigOrientation = Quaternion.LookRotation(dir, curState.ReferenceUp); rigOrientation = rigOrientation.ApplyCameraRotation( -m_ScreenOffsetPrevFrame, curState.ReferenceUp); } // Move target through the soft zone, with damping RotateToScreenBounds( ref curState, mCache.mFovSoftGuideRect, TrackedPoint, ref rigOrientation, mCache.mFov, mCache.mFovH, deltaTime); // Force the actual target (not the lookahead one) into the hard bounds, no damping if (deltaTime < 0 || VirtualCamera.LookAtTargetAttachment > 1 - Epsilon) { RotateToScreenBounds( ref curState, mCache.mFovHardGuideRect, curState.ReferenceLookAt, ref rigOrientation, mCache.mFov, mCache.mFovH, -1); } } m_CameraPosPrevFrame = curState.CorrectedPosition; m_LookAtPrevFrame = TrackedPoint; m_CameraOrientationPrevFrame = UnityQuaternionExtensions.Normalized(rigOrientation); m_ScreenOffsetPrevFrame = m_CameraOrientationPrevFrame.GetCameraRotationToTarget( m_LookAtPrevFrame - curState.CorrectedPosition, curState.ReferenceUp); curState.RawOrientation = m_CameraOrientationPrevFrame; }
/// <summary>Applies the composer rules and orients the camera accordingly</summary> /// <param name="curState">The current camera state</param> /// <param name="deltaTime">Used for calculating damping. If less than /// zero, then target will snap to the center of the dead zone.</param> public override void MutateCameraState(ref CameraState curState, float deltaTime) { // Initialize the state for previous frame if appropriate if (deltaTime < 0) { m_Predictor.Reset(); } if (!IsValid || !curState.HasLookAt) { return; } float targetDistance = (TrackedPoint - curState.CorrectedPosition).magnitude; if (targetDistance < Epsilon) { if (deltaTime >= 0) { curState.RawOrientation = m_CameraOrientationPrevFrame; } return; // navel-gazing, get outa here } float fov, fovH; if (curState.Lens.Orthographic) { // Calculate effective fov - fake it for ortho based on target distance fov = Mathf.Rad2Deg * 2 * Mathf.Atan(curState.Lens.OrthographicSize / targetDistance); fovH = Mathf.Rad2Deg * 2 * Mathf.Atan( curState.Lens.Aspect * curState.Lens.OrthographicSize / targetDistance); } else { fov = curState.Lens.FieldOfView; double radHFOV = 2 * Math.Atan(Math.Tan(fov * Mathf.Deg2Rad / 2) * curState.Lens.Aspect); fovH = (float)(Mathf.Rad2Deg * radHFOV); } Quaternion rigOrientation = curState.RawOrientation; Rect softGuideFOV = ScreenToFOV(SoftGuideRect, fov, fovH, curState.Lens.Aspect); if (deltaTime < 0) { // No damping, just snap to central bounds, skipping the soft zone Rect rect = new Rect(softGuideFOV.center, Vector2.zero); // Force to center RotateToScreenBounds(ref curState, rect, ref rigOrientation, fov, fovH, -1); } else { // Start with previous frame's orientation (but with current up) Vector3 dir = m_LookAtPrevFrame - (m_CameraPosPrevFrame + curState.PositionDampingBypass); if (dir.AlmostZero()) { rigOrientation = Quaternion.LookRotation( m_CameraOrientationPrevFrame * Vector3.forward, curState.ReferenceUp); } else { rigOrientation = Quaternion.LookRotation(dir, curState.ReferenceUp); rigOrientation = rigOrientation.ApplyCameraRotation( -m_ScreenOffsetPrevFrame, curState.ReferenceUp); } // First force the previous rotation into the hard bounds, no damping, // then Now move it through the soft zone, with damping Rect hardGuideFOV = ScreenToFOV(HardGuideRect, fov, fovH, curState.Lens.Aspect); if (!RotateToScreenBounds(ref curState, hardGuideFOV, ref rigOrientation, fov, fovH, -1)) { RotateToScreenBounds(ref curState, softGuideFOV, ref rigOrientation, fov, fovH, deltaTime); } } m_CameraPosPrevFrame = curState.CorrectedPosition; m_LookAtPrevFrame = TrackedPoint; m_CameraOrientationPrevFrame = UnityQuaternionExtensions.Normalized(rigOrientation); m_ScreenOffsetPrevFrame = m_CameraOrientationPrevFrame.GetCameraRotationToTarget( m_LookAtPrevFrame - curState.CorrectedPosition, curState.ReferenceUp); curState.RawOrientation = m_CameraOrientationPrevFrame; }
/// <summary>Intelligently blend the contents of two states.</summary> /// <param name="stateA">The first state, corresponding to t=0</param> /// <param name="stateB">The second state, corresponding to t=1</param> /// <param name="t">PHow much to interpolate. Internally clamped to 0..1</param> /// <returns>Linearly interpolated CameraState</returns> public static CameraState Lerp(CameraState stateA, CameraState stateB, float t) { t = Mathf.Clamp01(t); float adjustedT = t; CameraState state = new CameraState(); state.Lens = LensSettings.Lerp(stateA.Lens, stateB.Lens, t); state.ReferenceUp = Vector3.Slerp(stateA.ReferenceUp, stateB.ReferenceUp, t); state.RawPosition = Vector3.Lerp(stateA.RawPosition, stateB.RawPosition, t); Vector3 dirTarget = Vector3.zero; if (!stateA.HasLookAt || !stateB.HasLookAt) { state.ReferenceLookAt = kNoPoint; // can't interpolate if undefined } else { // Re-interpolate FOV to preserve target composition, if possible float fovA = stateA.Lens.FieldOfView; float fovB = stateB.Lens.FieldOfView; if (!Mathf.Approximately(fovA, fovB)) { LensSettings lens = state.Lens; lens.FieldOfView = state.InterpolateFOV( fovA, fovB, (stateA.ReferenceLookAt - stateA.RawPosition).magnitude, (stateB.ReferenceLookAt - stateB.RawPosition).magnitude, t); state.Lens = lens; // Make sure we preserve the screen composition through FOV changes adjustedT = Mathf.Abs((lens.FieldOfView - fovA) / (fovB - fovA)); } // Spherical linear interpolation about RawPosition state.ReferenceLookAt = state.RawPosition + Vector3.Slerp( stateA.ReferenceLookAt - state.RawPosition, stateB.ReferenceLookAt - state.RawPosition, adjustedT); dirTarget = state.ReferenceLookAt - state.RawPosition; } // Clever orientation interpolation if (dirTarget.AlmostZero()) { // Don't know what we're looking at - can only slerp state.RawOrientation = UnityQuaternionExtensions.SlerpWithReferenceUp( stateA.RawOrientation, stateB.RawOrientation, t, state.ReferenceUp); } else { // Rotate while preserving our lookAt target dirTarget = dirTarget.normalized; if ((dirTarget - state.ReferenceUp).AlmostZero() || (dirTarget + state.ReferenceUp).AlmostZero()) { // Looking up or down at the pole state.RawOrientation = UnityQuaternionExtensions.SlerpWithReferenceUp( stateA.RawOrientation, stateB.RawOrientation, t, state.ReferenceUp); } else { // Put the target in the center state.RawOrientation = Quaternion.LookRotation(dirTarget, state.ReferenceUp); // Blend the desired offsets from center Vector2 deltaA = -stateA.RawOrientation.GetCameraRotationToTarget( stateA.ReferenceLookAt - stateA.RawPosition, stateA.ReferenceUp); Vector2 deltaB = -stateB.RawOrientation.GetCameraRotationToTarget( stateB.ReferenceLookAt - stateB.RawPosition, stateB.ReferenceUp); state.RawOrientation = state.RawOrientation.ApplyCameraRotation( Vector2.Lerp(deltaA, deltaB, adjustedT), state.ReferenceUp); } } state.ShotQuality = Mathf.Lerp(stateA.ShotQuality, stateB.ShotQuality, t); state.PositionCorrection = Vector3.Lerp( stateA.PositionCorrection, stateB.PositionCorrection, t); // GML todo: is this right? Can it introduce a roll? state.OrientationCorrection = Quaternion.Slerp( stateA.OrientationCorrection, stateB.OrientationCorrection, t); return(state); }
/// <summary>Applies the composer rules and orients the camera accordingly</summary> /// <param name="curState">The current camera state</param> /// <param name="deltaTime">Used for calculating damping. If less than /// zero, then target will snap to the center of the dead zone.</param> public override void MutateCameraState(ref CameraState curState, float deltaTime) { // Initialize the state for previous frame if appropriate if (deltaTime < 0) { m_Predictor.Reset(); } if (!IsValid || !curState.HasLookAt) { return; } float targetDistance = (TrackedPoint - curState.CorrectedPosition).magnitude; if (targetDistance < Epsilon) { if (deltaTime >= 0) { curState.RawOrientation = m_CameraOrientationPrevFrame; } return; // navel-gazing, get outa here } // Expensive FOV calculations mCache.UpdateCache(curState.Lens, SoftGuideRect, HardGuideRect, targetDistance); Quaternion rigOrientation = curState.RawOrientation; if (deltaTime < 0) { // No damping, just snap to central bounds, skipping the soft zone Rect rect = mCache.mFovSoftGuideRect; if (m_CenterOnActivate) { rect = new Rect(rect.center, Vector2.zero); // Force to center } RotateToScreenBounds(ref curState, rect, ref rigOrientation, mCache.mFov, mCache.mFovH, -1); } else { // Start with previous frame's orientation (but with current up) Vector3 dir = m_LookAtPrevFrame - (m_CameraPosPrevFrame + curState.PositionDampingBypass); if (dir.AlmostZero()) { rigOrientation = Quaternion.LookRotation( m_CameraOrientationPrevFrame * Vector3.forward, curState.ReferenceUp); } else { rigOrientation = Quaternion.LookRotation(dir, curState.ReferenceUp); rigOrientation = rigOrientation.ApplyCameraRotation( -m_ScreenOffsetPrevFrame, curState.ReferenceUp); } // First force the previous rotation into the hard bounds, no damping, // then Now move it through the soft zone, with damping if (!RotateToScreenBounds(ref curState, mCache.mFovHardGuideRect, ref rigOrientation, mCache.mFov, mCache.mFovH, -1)) { RotateToScreenBounds(ref curState, mCache.mFovSoftGuideRect, ref rigOrientation, mCache.mFov, mCache.mFovH, deltaTime); } } m_CameraPosPrevFrame = curState.CorrectedPosition; m_LookAtPrevFrame = TrackedPoint; m_CameraOrientationPrevFrame = UnityQuaternionExtensions.Normalized(rigOrientation); m_ScreenOffsetPrevFrame = m_CameraOrientationPrevFrame.GetCameraRotationToTarget( m_LookAtPrevFrame - curState.CorrectedPosition, curState.ReferenceUp); curState.RawOrientation = m_CameraOrientationPrevFrame; }
public static CameraState Lerp(CameraState stateA, CameraState stateB, float t) { t = Mathf.Clamp01(t); float t2 = t; CameraState result = default(CameraState); result.Lens = LensSettings.Lerp(stateA.Lens, stateB.Lens, t); result.ReferenceUp = Vector3.Slerp(stateA.ReferenceUp, stateB.ReferenceUp, t); result.RawPosition = Vector3.Lerp(stateA.RawPosition, stateB.RawPosition, t); result.ShotQuality = Mathf.Lerp(stateA.ShotQuality, stateB.ShotQuality, t); result.PositionCorrection = Vector3.Lerp(stateA.PositionCorrection, stateB.PositionCorrection, t); result.OrientationCorrection = Quaternion.Slerp(stateA.OrientationCorrection, stateB.OrientationCorrection, t); Vector3 vector = Vector3.zero; if (!stateA.HasLookAt || !stateB.HasLookAt) { result.ReferenceLookAt = CameraState.kNoPoint; } else { float fieldOfView = stateA.Lens.FieldOfView; float fieldOfView2 = stateB.Lens.FieldOfView; if (!result.Lens.Orthographic && !Mathf.Approximately(fieldOfView, fieldOfView2)) { LensSettings lens = result.Lens; lens.FieldOfView = result.InterpolateFOV(fieldOfView, fieldOfView2, Mathf.Max((stateA.ReferenceLookAt - stateA.CorrectedPosition).magnitude, stateA.Lens.NearClipPlane), Mathf.Max((stateB.ReferenceLookAt - stateB.CorrectedPosition).magnitude, stateB.Lens.NearClipPlane), t); result.Lens = lens; t2 = Mathf.Abs((lens.FieldOfView - fieldOfView) / (fieldOfView2 - fieldOfView)); } result.ReferenceLookAt = Vector3.Lerp(stateA.ReferenceLookAt, stateB.ReferenceLookAt, t2); float num = Quaternion.Angle(stateA.RawOrientation, stateB.RawOrientation); if (num > 0.0001f) { vector = result.ReferenceLookAt - result.CorrectedPosition; } } if (vector.AlmostZero()) { result.RawOrientation = UnityQuaternionExtensions.SlerpWithReferenceUp(stateA.RawOrientation, stateB.RawOrientation, t, result.ReferenceUp); } else { vector = vector.normalized; if ((vector - result.ReferenceUp).AlmostZero() || (vector + result.ReferenceUp).AlmostZero()) { result.RawOrientation = UnityQuaternionExtensions.SlerpWithReferenceUp(stateA.RawOrientation, stateB.RawOrientation, t, result.ReferenceUp); } else { result.RawOrientation = Quaternion.LookRotation(vector, result.ReferenceUp); Vector2 a = -stateA.RawOrientation.GetCameraRotationToTarget(stateA.ReferenceLookAt - stateA.CorrectedPosition, stateA.ReferenceUp); Vector2 b = -stateB.RawOrientation.GetCameraRotationToTarget(stateB.ReferenceLookAt - stateB.CorrectedPosition, stateB.ReferenceUp); result.RawOrientation = result.RawOrientation.ApplyCameraRotation(Vector2.Lerp(a, b, t2), result.ReferenceUp); } } for (int i = 0; i < stateA.NumCustomBlendables; i++) { CameraState.CustomBlendable customBlendable = stateA.GetCustomBlendable(i); customBlendable.m_Weight *= 1f - t; if (customBlendable.m_Weight > 0.0001f) { result.AddCustomBlendable(customBlendable); } } for (int j = 0; j < stateB.NumCustomBlendables; j++) { CameraState.CustomBlendable customBlendable2 = stateB.GetCustomBlendable(j); customBlendable2.m_Weight *= t; if (customBlendable2.m_Weight > 0.0001f) { result.AddCustomBlendable(customBlendable2); } } return(result); }
/// <summary>Intelligently blend the contents of two states.</summary> /// <param name="stateA">The first state, corresponding to t=0</param> /// <param name="stateB">The second state, corresponding to t=1</param> /// <param name="t">How much to interpolate. Internally clamped to 0..1</param> /// <returns>Linearly interpolated CameraState</returns> public static CameraState Lerp(CameraState stateA, CameraState stateB, float t) { t = Mathf.Clamp01(t); float adjustedT = t; CameraState state = new CameraState(); state.Lens = LensSettings.Lerp(stateA.Lens, stateB.Lens, t); state.ReferenceUp = Vector3.Slerp(stateA.ReferenceUp, stateB.ReferenceUp, t); state.RawPosition = Vector3.Lerp(stateA.RawPosition, stateB.RawPosition, t); state.ShotQuality = Mathf.Lerp(stateA.ShotQuality, stateB.ShotQuality, t); state.PositionCorrection = Vector3.Lerp( stateA.PositionCorrection, stateB.PositionCorrection, t); // GML todo: is this right? Can it introduce a roll? state.OrientationCorrection = Quaternion.Slerp( stateA.OrientationCorrection, stateB.OrientationCorrection, t); Vector3 dirTarget = Vector3.zero; if (!stateA.HasLookAt || !stateB.HasLookAt) { state.ReferenceLookAt = kNoPoint; // can't interpolate if undefined } else { // Re-interpolate FOV to preserve target composition, if possible float fovA = stateA.Lens.FieldOfView; float fovB = stateB.Lens.FieldOfView; if (!state.Lens.Orthographic && !Mathf.Approximately(fovA, fovB)) { LensSettings lens = state.Lens; lens.FieldOfView = state.InterpolateFOV( fovA, fovB, Mathf.Max((stateA.ReferenceLookAt - stateA.CorrectedPosition).magnitude, stateA.Lens.NearClipPlane), Mathf.Max((stateB.ReferenceLookAt - stateB.CorrectedPosition).magnitude, stateB.Lens.NearClipPlane), t); state.Lens = lens; // Make sure we preserve the screen composition through FOV changes adjustedT = Mathf.Abs((lens.FieldOfView - fovA) / (fovB - fovA)); } // Linear interpolation of lookAt target point state.ReferenceLookAt = Vector3.Lerp( stateA.ReferenceLookAt, stateB.ReferenceLookAt, adjustedT); // If orientations are different, use LookAt to blend them float angle = Quaternion.Angle(stateA.RawOrientation, stateB.RawOrientation); if (angle > UnityVectorExtensions.Epsilon) { dirTarget = state.ReferenceLookAt - state.CorrectedPosition; } } // Clever orientation interpolation if (dirTarget.AlmostZero()) { // Don't know what we're looking at - can only slerp state.RawOrientation = UnityQuaternionExtensions.SlerpWithReferenceUp( stateA.RawOrientation, stateB.RawOrientation, t, state.ReferenceUp); } else { // Rotate while preserving our lookAt target dirTarget = dirTarget.normalized; if ((dirTarget - state.ReferenceUp).AlmostZero() || (dirTarget + state.ReferenceUp).AlmostZero()) { // Looking up or down at the pole state.RawOrientation = UnityQuaternionExtensions.SlerpWithReferenceUp( stateA.RawOrientation, stateB.RawOrientation, t, state.ReferenceUp); } else { // Put the target in the center state.RawOrientation = Quaternion.LookRotation(dirTarget, state.ReferenceUp); // Blend the desired offsets from center Vector2 deltaA = -stateA.RawOrientation.GetCameraRotationToTarget( stateA.ReferenceLookAt - stateA.CorrectedPosition, stateA.ReferenceUp); Vector2 deltaB = -stateB.RawOrientation.GetCameraRotationToTarget( stateB.ReferenceLookAt - stateB.CorrectedPosition, stateB.ReferenceUp); state.RawOrientation = state.RawOrientation.ApplyCameraRotation( Vector2.Lerp(deltaA, deltaB, adjustedT), state.ReferenceUp); } } // Accumulate the custom blendables and apply the weights for (int i = 0; i < stateA.NumCustomBlendables; ++i) { CustomBlendable b = stateA.GetCustomBlendable(i); b.m_Weight *= (1 - t); if (b.m_Weight > UnityVectorExtensions.Epsilon) { state.AddCustomBlendable(b); } } for (int i = 0; i < stateB.NumCustomBlendables; ++i) { CustomBlendable b = stateB.GetCustomBlendable(i); b.m_Weight *= t; if (b.m_Weight > UnityVectorExtensions.Epsilon) { state.AddCustomBlendable(b); } } return(state); }
/// <summary>Applies the composer rules and orients the camera accordingly</summary> /// <param name="curState">The current camera state</param> /// <param name="deltaTime">Used for calculating damping. If less than /// or equal to zero, then target will snap to the center of the dead zone.</param> public virtual void MutateCameraState(ref CameraState curState, float deltaTime) { // Initialize the state for previous frame if appropriate if (deltaTime <= 0) { m_CameraOrientationPrevFrame = curState.RawOrientation; } if (!IsValid || !curState.HasLookAt) { return; } curState.ReferenceLookAt = GetTrackedPoint(curState.ReferenceLookAt); float targetDistance = (curState.ReferenceLookAt - curState.CorrectedPosition).magnitude; if (targetDistance < UnityVectorExtensions.Epsilon) { return; // navel-gazing, get outa here } //UnityEngine.Profiling.Profiler.BeginSample("CinemachineComposer.MutateCameraState"); float fov, fovH; if (curState.Lens.Orthographic) { // Calculate effective fov - fake it for ortho based on target distance fov = Mathf.Rad2Deg * 2 * Mathf.Atan(curState.Lens.OrthographicSize / targetDistance); fovH = Mathf.Rad2Deg * 2 * Mathf.Atan( curState.Lens.Aspect * curState.Lens.OrthographicSize / targetDistance); } else { fov = curState.Lens.FieldOfView; double radHFOV = 2 * Math.Atan(Math.Tan(fov * Mathf.Deg2Rad / 2) * curState.Lens.Aspect); fovH = (float)(Mathf.Rad2Deg * radHFOV); } Rect softGuideFOV = ScreenToFOV(SoftGuideRect, fov, fovH, curState.Lens.Aspect); if (deltaTime <= 0) { // No damping, just snap to central bounds, skipping the soft zone Rect rect = new Rect(softGuideFOV.center, Vector2.zero); // Force to center curState.RawOrientation = RotateToScreenBounds( ref curState, rect, curState.RawOrientation, fov, fovH, 0); } else { // Start with previous frame's orientation (but with current up) Quaternion rigOrientation = Quaternion.LookRotation( m_CameraOrientationPrevFrame * Vector3.forward, curState.ReferenceUp); // First force the previous rotation into the hard bounds, no damping Rect hardGuideFOV = ScreenToFOV(HardGuideRect, fov, fovH, curState.Lens.Aspect); curState.RawOrientation = RotateToScreenBounds( ref curState, hardGuideFOV, rigOrientation, fov, fovH, 0); // Now move it through the soft zone, with damping curState.RawOrientation = RotateToScreenBounds( ref curState, softGuideFOV, curState.RawOrientation, fov, fovH, deltaTime); } curState.RawOrientation = m_CameraOrientationPrevFrame = UnityQuaternionExtensions.Normalized(curState.RawOrientation); //UnityEngine.Profiling.Profiler.EndSample(); }