691 lines
36 KiB
C#
691 lines
36 KiB
C#
using System;
|
|
using Cinemachine.Utility;
|
|
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
|
|
namespace Cinemachine
|
|
{
|
|
/// <summary>
|
|
/// This is a Cinemachine Component in the Body section of the component pipeline.
|
|
/// Its job is to position the camera in a fixed screen-space relationship to
|
|
/// the vcam's Follow target object, with offsets and damping.
|
|
///
|
|
/// The camera will be first moved along the camera Z axis until the Follow target
|
|
/// is at the desired distance from the camera's X-Y plane. The camera will then
|
|
/// be moved in its XY plane until the Follow target is at the desired point on
|
|
/// the camera's screen.
|
|
///
|
|
/// The FramingTansposer will only change the camera's position in space. It will not
|
|
/// re-orient or otherwise aim the camera.
|
|
///
|
|
/// For this component to work properly, the vcam's LookAt target must be null.
|
|
/// The Follow target will define what the camera is looking at.
|
|
///
|
|
/// If the Follow target is a ICinemachineTargetGroup, then additional controls will
|
|
/// be available to dynamically adjust the camera's view in order to frame the entire group.
|
|
///
|
|
/// Although this component was designed for orthographic cameras, it works equally
|
|
/// well with persective cameras and can be used in 3D environments.
|
|
/// </summary>
|
|
[DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
|
|
[AddComponentMenu("")] // Don't display in add component menu
|
|
[SaveDuringPlay]
|
|
public class CinemachineFramingTransposer : CinemachineComponentBase
|
|
{
|
|
/// <summary>
|
|
/// Offset from the Follow Target object (in target-local co-ordinates). The camera will attempt to
|
|
/// frame the point which is the target's position plus this offset. Use it to correct for
|
|
/// cases when the target's origin is not the point of interest for the camera.
|
|
/// </summary>
|
|
[Tooltip("Offset from the Follow Target object (in target-local co-ordinates). "
|
|
+ "The camera will attempt to frame the point which is the target's position plus "
|
|
+ "this offset. Use it to correct for cases when the target's origin is not the "
|
|
+ "point of interest for the camera.")]
|
|
public Vector3 m_TrackedObjectOffset;
|
|
|
|
/// <summary>This setting will instruct the composer to adjust its target offset based
|
|
/// on the motion of the target. The composer will look at a point where it estimates
|
|
/// the target will be this many seconds into the future. Note that this setting is sensitive
|
|
/// to noisy animation, and can amplify the noise, resulting in undesirable camera jitter.
|
|
/// If the camera jitters unacceptably when the target is in motion, turn down this setting,
|
|
/// or animate the target more smoothly.</summary>
|
|
[Tooltip("This setting will instruct the composer to adjust its target offset based on the "
|
|
+ "motion of the target. The composer will look at a point where it estimates the target "
|
|
+ "will be this many seconds into the future. Note that this setting is sensitive to noisy "
|
|
+ "animation, and can amplify the noise, resulting in undesirable camera jitter. "
|
|
+ "If the camera jitters unacceptably when the target is in motion, turn down this "
|
|
+ "setting, or animate the target more smoothly.")]
|
|
[Range(0f, 1f)]
|
|
[Space]
|
|
public float m_LookaheadTime = 0;
|
|
|
|
/// <summary>Controls the smoothness of the lookahead algorithm. Larger values smooth out
|
|
/// jittery predictions and also increase prediction lag</summary>
|
|
[Tooltip("Controls the smoothness of the lookahead algorithm. Larger values smooth out "
|
|
+ "jittery predictions and also increase prediction lag")]
|
|
[Range(0, 30)]
|
|
public float m_LookaheadSmoothing = 0;
|
|
|
|
/// <summary>If checked, movement along the Y axis will be ignored for lookahead calculations</summary>
|
|
[Tooltip("If checked, movement along the Y axis will be ignored for lookahead calculations")]
|
|
public bool m_LookaheadIgnoreY;
|
|
|
|
/// <summary>How aggressively the camera tries to maintain the offset in the X-axis.
|
|
/// Small numbers are more responsive, rapidly translating the camera to keep the target's
|
|
/// x-axis offset. Larger numbers give a more heavy slowly responding camera.
|
|
/// Using different settings per axis can yield a wide range of camera behaviors</summary>
|
|
[Space]
|
|
[Range(0f, 20f)]
|
|
[Tooltip("How aggressively the camera tries to maintain the offset in the X-axis. "
|
|
+ "Small numbers are more responsive, rapidly translating the camera to keep the target's "
|
|
+ "x-axis offset. Larger numbers give a more heavy slowly responding camera. "
|
|
+ "Using different settings per axis can yield a wide range of camera behaviors.")]
|
|
public float m_XDamping = 1f;
|
|
|
|
/// <summary>How aggressively the camera tries to maintain the offset in the Y-axis.
|
|
/// Small numbers are more responsive, rapidly translating the camera to keep the target's
|
|
/// y-axis offset. Larger numbers give a more heavy slowly responding camera.
|
|
/// Using different settings per axis can yield a wide range of camera behaviors</summary>
|
|
[Range(0f, 20f)]
|
|
[Tooltip("How aggressively the camera tries to maintain the offset in the Y-axis. "
|
|
+ "Small numbers are more responsive, rapidly translating the camera to keep the target's "
|
|
+ "y-axis offset. Larger numbers give a more heavy slowly responding camera. "
|
|
+ "Using different settings per axis can yield a wide range of camera behaviors.")]
|
|
public float m_YDamping = 1f;
|
|
|
|
/// <summary>How aggressively the camera tries to maintain the offset in the Z-axis.
|
|
/// Small numbers are more responsive, rapidly translating the camera to keep the
|
|
/// target's z-axis offset. Larger numbers give a more heavy slowly responding camera.
|
|
/// Using different settings per axis can yield a wide range of camera behaviors</summary>
|
|
[Range(0f, 20f)]
|
|
[Tooltip("How aggressively the camera tries to maintain the offset in the Z-axis. "
|
|
+ "Small numbers are more responsive, rapidly translating the camera to keep the target's "
|
|
+ "z-axis offset. Larger numbers give a more heavy slowly responding camera. "
|
|
+ "Using different settings per axis can yield a wide range of camera behaviors.")]
|
|
public float m_ZDamping = 1f;
|
|
|
|
/// <summary>If set, damping will apply only to target motion, and not when
|
|
/// the camera rotation changes. Turn this on to get an instant response when
|
|
/// the rotation changes</summary>
|
|
[Tooltip("If set, damping will apply only to target motion, but not to camera "
|
|
+ "rotation changes. Turn this on to get an instant response when the rotation changes. ")]
|
|
public bool m_TargetMovementOnly = true;
|
|
|
|
/// <summary>Horizontal screen position for target. The camera will move to position the tracked object here</summary>
|
|
[Space]
|
|
[Range(-0.5f, 1.5f)]
|
|
[Tooltip("Horizontal screen position for target. The camera will move to position the tracked object here.")]
|
|
public float m_ScreenX = 0.5f;
|
|
|
|
/// <summary>Vertical screen position for target, The camera will move to to position the tracked object here</summary>
|
|
[Range(-0.5f, 1.5f)]
|
|
[Tooltip("Vertical screen position for target, The camera will move to position the tracked object here.")]
|
|
public float m_ScreenY = 0.5f;
|
|
|
|
/// <summary>The distance along the camera axis that will be maintained from the Follow target</summary>
|
|
[Tooltip("The distance along the camera axis that will be maintained from the Follow target")]
|
|
public float m_CameraDistance = 10f;
|
|
|
|
/// <summary>Camera will not move horizontally if the target is within this range of the position</summary>
|
|
[Space]
|
|
[Range(0f, 2f)]
|
|
[Tooltip("Camera will not move horizontally if the target is within this range of the position.")]
|
|
public float m_DeadZoneWidth = 0f;
|
|
|
|
/// <summary>Camera will not move vertically if the target is within this range of the position</summary>
|
|
[Range(0f, 2f)]
|
|
[Tooltip("Camera will not move vertically if the target is within this range of the position.")]
|
|
public float m_DeadZoneHeight = 0f;
|
|
|
|
/// <summary>The camera will not move along its z-axis if the Follow target is within
|
|
/// this distance of the specified camera distance</summary>
|
|
[Tooltip("The camera will not move along its z-axis if the Follow target is within "
|
|
+ "this distance of the specified camera distance")]
|
|
[FormerlySerializedAs("m_DistanceDeadZoneSize")]
|
|
public float m_DeadZoneDepth = 0;
|
|
|
|
/// <summary>If checked, then then soft zone will be unlimited in size</summary>
|
|
[Space]
|
|
[Tooltip("If checked, then then soft zone will be unlimited in size.")]
|
|
public bool m_UnlimitedSoftZone = false;
|
|
|
|
/// <summary>When target is within this region, camera will gradually move to re-align
|
|
/// towards the desired position, depending onm the damping speed</summary>
|
|
[Range(0f, 2f)]
|
|
[Tooltip("When target is within this region, camera will gradually move horizontally to "
|
|
+ "re-align towards the desired position, depending on the damping speed.")]
|
|
public float m_SoftZoneWidth = 0.8f;
|
|
|
|
/// <summary>When target is within this region, camera will gradually move to re-align
|
|
/// towards the desired position, depending onm the damping speed</summary>
|
|
[Range(0f, 2f)]
|
|
[Tooltip("When target is within this region, camera will gradually move vertically to "
|
|
+ "re-align towards the desired position, depending on the damping speed.")]
|
|
public float m_SoftZoneHeight = 0.8f;
|
|
|
|
/// <summary>A non-zero bias will move the targt position away from the center of the soft zone</summary>
|
|
[Range(-0.5f, 0.5f)]
|
|
[Tooltip("A non-zero bias will move the target position horizontally away from the center of the soft zone.")]
|
|
public float m_BiasX = 0f;
|
|
|
|
/// <summary>A non-zero bias will move the targt position away from the center of the soft zone</summary>
|
|
[Range(-0.5f, 0.5f)]
|
|
[Tooltip("A non-zero bias will move the target position vertically away from the center of the soft zone.")]
|
|
public float m_BiasY = 0f;
|
|
|
|
/// <summary>Force target to center of screen when this camera activates.
|
|
/// If false, will clamp target to the edges of the dead zone</summary>
|
|
[Tooltip("Force target to center of screen when this camera activates. "
|
|
+ "If false, will clamp target to the edges of the dead zone")]
|
|
public bool m_CenterOnActivate = true;
|
|
|
|
/// <summary>What screen dimensions to consider when framing</summary>
|
|
[DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
|
|
public enum FramingMode
|
|
{
|
|
/// <summary>Consider only the horizontal dimension. Vertical framing is ignored.</summary>
|
|
Horizontal,
|
|
/// <summary>Consider only the vertical dimension. Horizontal framing is ignored.</summary>
|
|
Vertical,
|
|
/// <summary>The larger of the horizontal and vertical dimensions will dominate, to get the best fit.</summary>
|
|
HorizontalAndVertical,
|
|
/// <summary>Don't do any framing adjustment</summary>
|
|
None
|
|
};
|
|
|
|
/// <summary>What screen dimensions to consider when framing</summary>
|
|
[Space]
|
|
[Tooltip("What screen dimensions to consider when framing. Can be Horizontal, Vertical, or both")]
|
|
[FormerlySerializedAs("m_FramingMode")]
|
|
public FramingMode m_GroupFramingMode = FramingMode.HorizontalAndVertical;
|
|
|
|
/// <summary>How to adjust the camera to get the desired framing</summary>
|
|
public enum AdjustmentMode
|
|
{
|
|
/// <summary>Do not move the camera, only adjust the FOV.</summary>
|
|
ZoomOnly,
|
|
/// <summary>Just move the camera, don't change the FOV.</summary>
|
|
DollyOnly,
|
|
/// <summary>Move the camera as much as permitted by the ranges, then
|
|
/// adjust the FOV if necessary to make the shot.</summary>
|
|
DollyThenZoom
|
|
};
|
|
|
|
/// <summary>How to adjust the camera to get the desired framing</summary>
|
|
[Tooltip("How to adjust the camera to get the desired framing. You can zoom, dolly in/out, or do both.")]
|
|
public AdjustmentMode m_AdjustmentMode = AdjustmentMode.ZoomOnly;
|
|
|
|
/// <summary>How much of the screen to fill with the bounding box of the targets.</summary>
|
|
[Tooltip("The bounding box of the targets should occupy this amount of the screen space. "
|
|
+ "1 means fill the whole screen. 0.5 means fill half the screen, etc.")]
|
|
public float m_GroupFramingSize = 0.8f;
|
|
|
|
/// <summary>How much closer to the target can the camera go?</summary>
|
|
[Tooltip("The maximum distance toward the target that this behaviour is allowed to move the camera.")]
|
|
public float m_MaxDollyIn = 5000f;
|
|
|
|
/// <summary>How much farther from the target can the camera go?</summary>
|
|
[Tooltip("The maximum distance away the target that this behaviour is allowed to move the camera.")]
|
|
public float m_MaxDollyOut = 5000f;
|
|
|
|
/// <summary>Set this to limit how close to the target the camera can get</summary>
|
|
[Tooltip("Set this to limit how close to the target the camera can get.")]
|
|
public float m_MinimumDistance = 1;
|
|
|
|
/// <summary>Set this to limit how far from the taregt the camera can get</summary>
|
|
[Tooltip("Set this to limit how far from the target the camera can get.")]
|
|
public float m_MaximumDistance = 5000f;
|
|
|
|
/// <summary>If adjusting FOV, will not set the FOV lower than this</summary>
|
|
[Range(1, 179)]
|
|
[Tooltip("If adjusting FOV, will not set the FOV lower than this.")]
|
|
public float m_MinimumFOV = 3;
|
|
|
|
/// <summary>If adjusting FOV, will not set the FOV higher than this</summary>
|
|
[Range(1, 179)]
|
|
[Tooltip("If adjusting FOV, will not set the FOV higher than this.")]
|
|
public float m_MaximumFOV = 60;
|
|
|
|
/// <summary>If adjusting Orthographic Size, will not set it lower than this</summary>
|
|
[Tooltip("If adjusting Orthographic Size, will not set it lower than this.")]
|
|
public float m_MinimumOrthoSize = 1;
|
|
|
|
/// <summary>If adjusting Orthographic Size, will not set it higher than this</summary>
|
|
[Tooltip("If adjusting Orthographic Size, will not set it higher than this.")]
|
|
public float m_MaximumOrthoSize = 5000;
|
|
|
|
/// <summary>Internal API for the inspector editor</summary>
|
|
internal Rect SoftGuideRect
|
|
{
|
|
get
|
|
{
|
|
return new Rect(
|
|
m_ScreenX - m_DeadZoneWidth / 2, m_ScreenY - m_DeadZoneHeight / 2,
|
|
m_DeadZoneWidth, m_DeadZoneHeight);
|
|
}
|
|
set
|
|
{
|
|
m_DeadZoneWidth = Mathf.Clamp(value.width, 0, 2);
|
|
m_DeadZoneHeight = Mathf.Clamp(value.height, 0, 2);
|
|
m_ScreenX = Mathf.Clamp(value.x + m_DeadZoneWidth / 2, -0.5f, 1.5f);
|
|
m_ScreenY = Mathf.Clamp(value.y + m_DeadZoneHeight / 2, -0.5f, 1.5f);
|
|
m_SoftZoneWidth = Mathf.Max(m_SoftZoneWidth, m_DeadZoneWidth);
|
|
m_SoftZoneHeight = Mathf.Max(m_SoftZoneHeight, m_DeadZoneHeight);
|
|
}
|
|
}
|
|
|
|
/// <summary>Internal API for the inspector editor</summary>
|
|
internal Rect HardGuideRect
|
|
{
|
|
get
|
|
{
|
|
Rect r = new Rect(
|
|
m_ScreenX - m_SoftZoneWidth / 2, m_ScreenY - m_SoftZoneHeight / 2,
|
|
m_SoftZoneWidth, m_SoftZoneHeight);
|
|
r.position += new Vector2(
|
|
m_BiasX * (m_SoftZoneWidth - m_DeadZoneWidth),
|
|
m_BiasY * (m_SoftZoneHeight - m_DeadZoneHeight));
|
|
return r;
|
|
}
|
|
set
|
|
{
|
|
m_SoftZoneWidth = Mathf.Clamp(value.width, 0, 2f);
|
|
m_SoftZoneHeight = Mathf.Clamp(value.height, 0, 2f);
|
|
m_DeadZoneWidth = Mathf.Min(m_DeadZoneWidth, m_SoftZoneWidth);
|
|
m_DeadZoneHeight = Mathf.Min(m_DeadZoneHeight, m_SoftZoneHeight);
|
|
|
|
Vector2 center = value.center;
|
|
Vector2 bias = center - new Vector2(m_ScreenX, m_ScreenY);
|
|
float biasWidth = Mathf.Max(0, m_SoftZoneWidth - m_DeadZoneWidth);
|
|
float biasHeight = Mathf.Max(0, m_SoftZoneHeight - m_DeadZoneHeight);
|
|
m_BiasX = biasWidth < Epsilon ? 0 : Mathf.Clamp(bias.x / biasWidth, -0.5f, 0.5f);
|
|
m_BiasY = biasHeight < Epsilon ? 0 : Mathf.Clamp(bias.y / biasHeight, -0.5f, 0.5f);
|
|
}
|
|
}
|
|
|
|
private void OnValidate()
|
|
{
|
|
m_CameraDistance = Mathf.Max(m_CameraDistance, kMinimumCameraDistance);
|
|
m_DeadZoneDepth = Mathf.Max(m_DeadZoneDepth, 0);
|
|
|
|
m_GroupFramingSize = Mathf.Max(0.001f, m_GroupFramingSize);
|
|
m_MaxDollyIn = Mathf.Max(0, m_MaxDollyIn);
|
|
m_MaxDollyOut = Mathf.Max(0, m_MaxDollyOut);
|
|
m_MinimumDistance = Mathf.Max(0, m_MinimumDistance);
|
|
m_MaximumDistance = Mathf.Max(m_MinimumDistance, m_MaximumDistance);
|
|
m_MinimumFOV = Mathf.Max(1, m_MinimumFOV);
|
|
m_MaximumFOV = Mathf.Clamp(m_MaximumFOV, m_MinimumFOV, 179);
|
|
m_MinimumOrthoSize = Mathf.Max(0.01f, m_MinimumOrthoSize);
|
|
m_MaximumOrthoSize = Mathf.Max(m_MinimumOrthoSize, m_MaximumOrthoSize);
|
|
}
|
|
|
|
/// <summary>True if component is enabled and has a valid Follow target</summary>
|
|
public override bool IsValid { get { return enabled && FollowTarget != null; } }
|
|
|
|
/// <summary>Get the Cinemachine Pipeline stage that this component implements.
|
|
/// Always returns the Body stage</summary>
|
|
public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Body; } }
|
|
|
|
/// <summary>FramingTransposer's algorithm tahes camera orientation as input,
|
|
/// so even though it is a Body component, it must apply after Aim</summary>
|
|
public override bool BodyAppliesAfterAim { get { return true; } }
|
|
|
|
const float kMinimumCameraDistance = 0.01f;
|
|
const float kMinimumGroupSize = 0.01f;
|
|
|
|
/// <summary>State information for damping</summary>
|
|
Vector3 m_PreviousCameraPosition = Vector3.zero;
|
|
internal PositionPredictor m_Predictor = new PositionPredictor();
|
|
|
|
/// <summary>Internal API for inspector</summary>
|
|
public Vector3 TrackedPoint { get; private set; }
|
|
|
|
/// <summary>This is called to notify the us that a target got warped,
|
|
/// so that we can update its internal state to make the camera
|
|
/// also warp seamlessy.</summary>
|
|
/// <param name="target">The object that was warped</param>
|
|
/// <param name="positionDelta">The amount the target's position changed</param>
|
|
public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
|
|
{
|
|
base.OnTargetObjectWarped(target, positionDelta);
|
|
if (target == FollowTarget)
|
|
{
|
|
m_PreviousCameraPosition += positionDelta;
|
|
m_Predictor.ApplyTransformDelta(positionDelta);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Force the virtual camera to assume a given position and orientation
|
|
/// </summary>
|
|
/// <param name="pos">Worldspace pposition to take</param>
|
|
/// <param name="rot">Worldspace orientation to take</param>
|
|
public override void ForceCameraPosition(Vector3 pos, Quaternion rot)
|
|
{
|
|
base.ForceCameraPosition(pos, rot);
|
|
m_PreviousCameraPosition = pos;
|
|
m_prevRotation = rot;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Report maximum damping time needed for this component.
|
|
/// </summary>
|
|
/// <returns>Highest damping setting in this component</returns>
|
|
public override float GetMaxDampTime()
|
|
{
|
|
return Mathf.Max(m_XDamping, Mathf.Max(m_YDamping, m_ZDamping));
|
|
}
|
|
|
|
/// <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>
|
|
/// <param name="transitionParams">Transition settings for this vcam</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)
|
|
{
|
|
if (fromCam != null && transitionParams.m_InheritPosition
|
|
&& !CinemachineCore.Instance.IsLiveInBlend(VirtualCamera))
|
|
{
|
|
m_PreviousCameraPosition = fromCam.State.RawPosition;
|
|
m_prevRotation = fromCam.State.RawOrientation;
|
|
m_InheritingPosition = true;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool m_InheritingPosition;
|
|
|
|
// Convert from screen coords to normalized orthographic distance coords
|
|
private Rect ScreenToOrtho(Rect rScreen, float orthoSize, float aspect)
|
|
{
|
|
Rect r = new Rect();
|
|
r.yMax = 2 * orthoSize * ((1f-rScreen.yMin) - 0.5f);
|
|
r.yMin = 2 * orthoSize * ((1f-rScreen.yMax) - 0.5f);
|
|
r.xMin = 2 * orthoSize * aspect * (rScreen.xMin - 0.5f);
|
|
r.xMax = 2 * orthoSize * aspect * (rScreen.xMax - 0.5f);
|
|
return r;
|
|
}
|
|
|
|
private Vector3 OrthoOffsetToScreenBounds(Vector3 targetPos2D, Rect screenRect)
|
|
{
|
|
// Bring it to the edge of screenRect, if outside. Leave it alone if inside.
|
|
Vector3 delta = Vector3.zero;
|
|
if (targetPos2D.x < screenRect.xMin)
|
|
delta.x += targetPos2D.x - screenRect.xMin;
|
|
if (targetPos2D.x > screenRect.xMax)
|
|
delta.x += targetPos2D.x - screenRect.xMax;
|
|
if (targetPos2D.y < screenRect.yMin)
|
|
delta.y += targetPos2D.y - screenRect.yMin;
|
|
if (targetPos2D.y > screenRect.yMax)
|
|
delta.y += targetPos2D.y - screenRect.yMax;
|
|
return delta;
|
|
}
|
|
|
|
float m_prevFOV; // State for frame damping
|
|
Quaternion m_prevRotation;
|
|
|
|
/// <summary>For editor visulaization of the calculated bounding box of the group</summary>
|
|
public Bounds LastBounds { get; private set; }
|
|
|
|
/// <summary>For editor visualization of the calculated bounding box of the group</summary>
|
|
public Matrix4x4 LastBoundsMatrix { get; private set; }
|
|
|
|
/// <summary>Positions the virtual camera according to the transposer rules.</summary>
|
|
/// <param name="curState">The current camera state</param>
|
|
/// <param name="deltaTime">Used for damping. If less than 0, no damping is done.</param>
|
|
public override void MutateCameraState(ref CameraState curState, float deltaTime)
|
|
{
|
|
LensSettings lens = curState.Lens;
|
|
Vector3 followTargetPosition = FollowTargetPosition + (FollowTargetRotation * m_TrackedObjectOffset);
|
|
bool previousStateIsValid = deltaTime >= 0 && VirtualCamera.PreviousStateIsValid;
|
|
if (!previousStateIsValid || VirtualCamera.FollowTargetChanged)
|
|
m_Predictor.Reset();
|
|
if (!previousStateIsValid)
|
|
{
|
|
m_PreviousCameraPosition = curState.RawPosition;
|
|
m_prevFOV = lens.Orthographic ? lens.OrthographicSize : lens.FieldOfView;
|
|
m_prevRotation = curState.RawOrientation;
|
|
if (!m_InheritingPosition && m_CenterOnActivate)
|
|
{
|
|
m_PreviousCameraPosition = FollowTargetPosition
|
|
+ (curState.RawOrientation * Vector3.back) * m_CameraDistance;
|
|
}
|
|
}
|
|
if (!IsValid)
|
|
{
|
|
m_InheritingPosition = false;
|
|
return;
|
|
}
|
|
|
|
var verticalFOV = lens.FieldOfView;
|
|
|
|
// Compute group bounds and adjust follow target for group framing
|
|
ICinemachineTargetGroup group = AbstractFollowTargetGroup;
|
|
bool isGroupFraming = group != null && m_GroupFramingMode != FramingMode.None && !group.IsEmpty;
|
|
if (isGroupFraming)
|
|
followTargetPosition = ComputeGroupBounds(group, ref curState);
|
|
|
|
TrackedPoint = followTargetPosition;
|
|
if (m_LookaheadTime > Epsilon)
|
|
{
|
|
m_Predictor.Smoothing = m_LookaheadSmoothing;
|
|
m_Predictor.AddPosition(followTargetPosition, deltaTime, m_LookaheadTime);
|
|
var delta = m_Predictor.PredictPositionDelta(m_LookaheadTime);
|
|
if (m_LookaheadIgnoreY)
|
|
delta = delta.ProjectOntoPlane(curState.ReferenceUp);
|
|
var p = followTargetPosition + delta;
|
|
if (isGroupFraming)
|
|
{
|
|
var b = LastBounds;
|
|
b.center += LastBoundsMatrix.MultiplyPoint3x4(delta);
|
|
LastBounds = b;
|
|
}
|
|
TrackedPoint = p;
|
|
}
|
|
|
|
if (!curState.HasLookAt)
|
|
curState.ReferenceLookAt = followTargetPosition;
|
|
|
|
// Adjust the desired depth for group framing
|
|
float targetDistance = m_CameraDistance;
|
|
bool isOrthographic = lens.Orthographic;
|
|
float targetHeight = isGroupFraming ? GetTargetHeight(LastBounds.size / m_GroupFramingSize) : 0;
|
|
targetHeight = Mathf.Max(targetHeight, kMinimumGroupSize);
|
|
if (!isOrthographic && isGroupFraming)
|
|
{
|
|
// Adjust height for perspective - we want the height at the near surface
|
|
float boundsDepth = LastBounds.extents.z;
|
|
float z = LastBounds.center.z;
|
|
if (z > boundsDepth)
|
|
targetHeight = Mathf.Lerp(0, targetHeight, (z - boundsDepth) / z);
|
|
|
|
if (m_AdjustmentMode != AdjustmentMode.ZoomOnly)
|
|
{
|
|
// What distance from near edge would be needed to get the adjusted
|
|
// target height, at the current FOV
|
|
targetDistance = targetHeight / (2f * Mathf.Tan(verticalFOV * Mathf.Deg2Rad / 2f));
|
|
|
|
// Clamp to respect min/max distance settings to the near surface of the bounds
|
|
targetDistance = Mathf.Clamp(targetDistance, m_MinimumDistance, m_MaximumDistance);
|
|
|
|
// Clamp to respect min/max camera movement
|
|
float targetDelta = targetDistance - m_CameraDistance;
|
|
targetDelta = Mathf.Clamp(targetDelta, -m_MaxDollyIn, m_MaxDollyOut);
|
|
targetDistance = m_CameraDistance + targetDelta;
|
|
}
|
|
}
|
|
|
|
// Optionally allow undamped camera orientation change
|
|
Quaternion localToWorld = curState.RawOrientation;
|
|
if (previousStateIsValid && m_TargetMovementOnly)
|
|
{
|
|
var q = localToWorld * Quaternion.Inverse(m_prevRotation);
|
|
m_PreviousCameraPosition = TrackedPoint + q * (m_PreviousCameraPosition - TrackedPoint);
|
|
}
|
|
m_prevRotation = localToWorld;
|
|
|
|
// Work in camera-local space
|
|
Vector3 camPosWorld = m_PreviousCameraPosition;
|
|
Quaternion worldToLocal = Quaternion.Inverse(localToWorld);
|
|
Vector3 cameraPos = worldToLocal * camPosWorld;
|
|
Vector3 targetPos = (worldToLocal * TrackedPoint) - cameraPos;
|
|
Vector3 lookAtPos = targetPos;
|
|
|
|
// Move along camera z
|
|
Vector3 cameraOffset = Vector3.zero;
|
|
float cameraMin = Mathf.Max(kMinimumCameraDistance, targetDistance - m_DeadZoneDepth/2);
|
|
float cameraMax = Mathf.Max(cameraMin, targetDistance + m_DeadZoneDepth/2);
|
|
float targetZ = Mathf.Min(targetPos.z, lookAtPos.z);
|
|
if (targetZ < cameraMin)
|
|
cameraOffset.z = targetZ - cameraMin;
|
|
if (targetZ > cameraMax)
|
|
cameraOffset.z = targetZ - cameraMax;
|
|
|
|
// Move along the XY plane
|
|
float screenSize = lens.Orthographic
|
|
? lens.OrthographicSize
|
|
: Mathf.Tan(0.5f * verticalFOV * Mathf.Deg2Rad) * (targetZ - cameraOffset.z);
|
|
Rect softGuideOrtho = ScreenToOrtho(SoftGuideRect, screenSize, lens.Aspect);
|
|
if (!previousStateIsValid)
|
|
{
|
|
// No damping or hard bounds, just snap to central bounds, skipping the soft zone
|
|
Rect rect = softGuideOrtho;
|
|
if (m_CenterOnActivate && !m_InheritingPosition)
|
|
rect = new Rect(rect.center, Vector2.zero); // Force to center
|
|
cameraOffset += OrthoOffsetToScreenBounds(targetPos, rect);
|
|
}
|
|
else
|
|
{
|
|
// Move it through the soft zone, with damping
|
|
cameraOffset += OrthoOffsetToScreenBounds(targetPos, softGuideOrtho);
|
|
cameraOffset = VirtualCamera.DetachedFollowTargetDamp(
|
|
cameraOffset, new Vector3(m_XDamping, m_YDamping, m_ZDamping), deltaTime);
|
|
|
|
// Make sure the real target (not the lookahead one) is still in the frame
|
|
if (!m_UnlimitedSoftZone
|
|
&& (deltaTime < 0 || VirtualCamera.FollowTargetAttachment > 1 - Epsilon))
|
|
{
|
|
Rect hardGuideOrtho = ScreenToOrtho(HardGuideRect, screenSize, lens.Aspect);
|
|
var realTargetPos = (worldToLocal * followTargetPosition) - cameraPos;
|
|
cameraOffset += OrthoOffsetToScreenBounds(
|
|
realTargetPos - cameraOffset, hardGuideOrtho);
|
|
}
|
|
}
|
|
curState.RawPosition = localToWorld * (cameraPos + cameraOffset);
|
|
m_PreviousCameraPosition = curState.RawPosition;
|
|
|
|
// Adjust lens for group framing
|
|
if (isGroupFraming)
|
|
{
|
|
if (isOrthographic)
|
|
{
|
|
targetHeight = Mathf.Clamp(targetHeight / 2, m_MinimumOrthoSize, m_MaximumOrthoSize);
|
|
|
|
// Apply Damping
|
|
if (previousStateIsValid)
|
|
targetHeight = m_prevFOV + VirtualCamera.DetachedFollowTargetDamp(
|
|
targetHeight - m_prevFOV, m_ZDamping, deltaTime);
|
|
m_prevFOV = targetHeight;
|
|
|
|
lens.OrthographicSize = Mathf.Clamp(targetHeight, m_MinimumOrthoSize, m_MaximumOrthoSize);
|
|
curState.Lens = lens;
|
|
}
|
|
else if (m_AdjustmentMode != AdjustmentMode.DollyOnly)
|
|
{
|
|
var localTarget = Quaternion.Inverse(curState.RawOrientation)
|
|
* (followTargetPosition - curState.RawPosition);
|
|
float nearBoundsDistance = localTarget.z;
|
|
float targetFOV = 179;
|
|
if (nearBoundsDistance > Epsilon)
|
|
targetFOV = 2f * Mathf.Atan(targetHeight / (2 * nearBoundsDistance)) * Mathf.Rad2Deg;
|
|
targetFOV = Mathf.Clamp(targetFOV, m_MinimumFOV, m_MaximumFOV);
|
|
|
|
// ApplyDamping
|
|
if (previousStateIsValid)
|
|
targetFOV = m_prevFOV + VirtualCamera.DetachedFollowTargetDamp(
|
|
targetFOV - m_prevFOV, m_ZDamping, deltaTime);
|
|
m_prevFOV = targetFOV;
|
|
|
|
lens.FieldOfView = targetFOV;
|
|
curState.Lens = lens;
|
|
}
|
|
}
|
|
m_InheritingPosition = false;
|
|
}
|
|
|
|
float GetTargetHeight(Vector2 boundsSize)
|
|
{
|
|
switch (m_GroupFramingMode)
|
|
{
|
|
case FramingMode.Horizontal:
|
|
return boundsSize.x / VcamState.Lens.Aspect;
|
|
case FramingMode.Vertical:
|
|
return boundsSize.y;
|
|
default:
|
|
case FramingMode.HorizontalAndVertical:
|
|
return Mathf.Max(boundsSize.x / VcamState.Lens.Aspect, boundsSize.y);
|
|
}
|
|
}
|
|
|
|
Vector3 ComputeGroupBounds(ICinemachineTargetGroup group, ref CameraState curState)
|
|
{
|
|
Vector3 cameraPos = curState.RawPosition;
|
|
Vector3 fwd = curState.RawOrientation * Vector3.forward;
|
|
|
|
// Get the bounding box from camera's direction in view space
|
|
LastBoundsMatrix = Matrix4x4.TRS(cameraPos, curState.RawOrientation, Vector3.one);
|
|
Bounds b = group.GetViewSpaceBoundingBox(LastBoundsMatrix);
|
|
Vector3 groupCenter = LastBoundsMatrix.MultiplyPoint3x4(b.center);
|
|
float boundsDepth = b.extents.z;
|
|
if (!curState.Lens.Orthographic)
|
|
{
|
|
// Parallax might change bounds - refine
|
|
float d = (Quaternion.Inverse(curState.RawOrientation) * (groupCenter - cameraPos)).z;
|
|
cameraPos = groupCenter - fwd * (Mathf.Max(d, boundsDepth) + boundsDepth);
|
|
|
|
// Will adjust cameraPos
|
|
b = GetScreenSpaceGroupBoundingBox(group, ref cameraPos, curState.RawOrientation);
|
|
LastBoundsMatrix = Matrix4x4.TRS(cameraPos, curState.RawOrientation, Vector3.one);
|
|
groupCenter = LastBoundsMatrix.MultiplyPoint3x4(b.center);
|
|
}
|
|
LastBounds = b;
|
|
return groupCenter - fwd * boundsDepth;
|
|
}
|
|
|
|
static Bounds GetScreenSpaceGroupBoundingBox(
|
|
ICinemachineTargetGroup group, ref Vector3 pos, Quaternion orientation)
|
|
{
|
|
var observer = Matrix4x4.TRS(pos, orientation, Vector3.one);
|
|
group.GetViewSpaceAngularBounds(observer, out var minAngles, out var maxAngles, out var zRange);
|
|
var shift = (minAngles + maxAngles) / 2;
|
|
|
|
var q = Quaternion.identity.ApplyCameraRotation(new Vector2(-shift.x, shift.y), Vector3.up);
|
|
pos = q * new Vector3(0, 0, (zRange.y + zRange.x)/2);
|
|
pos.z = 0;
|
|
pos = observer.MultiplyPoint3x4(pos);
|
|
observer = Matrix4x4.TRS(pos, orientation, Vector3.one);
|
|
group.GetViewSpaceAngularBounds(observer, out minAngles, out maxAngles, out zRange);
|
|
|
|
// For width and height (in camera space) of the bounding box, we use the values at the center of the box.
|
|
// This is an arbitrary choice. The gizmo drawer will take this into account when displaying
|
|
// the frustum bounds of the group
|
|
var d = zRange.y + zRange.x;
|
|
Vector2 angles = new Vector2(89.5f, 89.5f);
|
|
if (zRange.x > 0)
|
|
{
|
|
angles = Vector2.Max(maxAngles, UnityVectorExtensions.Abs(minAngles));
|
|
angles = Vector2.Min(angles, new Vector2(89.5f, 89.5f));
|
|
}
|
|
angles *= Mathf.Deg2Rad;
|
|
return new Bounds(
|
|
new Vector3(0, 0, d/2),
|
|
new Vector3(Mathf.Tan(angles.y) * d, Mathf.Tan(angles.x) * d, zRange.y - zRange.x));
|
|
}
|
|
}
|
|
}
|