private void OnSceneGUI()
{
Event e = Event.current;
if (e.type == EventType.ExecuteCommand)
{
// Look at followTarget rather than rig transform if followTarget is set.
BaseVehicleDriver followTarget = serializedObject.FindProperty(MountedCameraRig.FOLLOW_TARGET_VARIABLE_NAME)?.objectReferenceValue as BaseVehicleDriver;
if (followTarget == null)
{
return;
}
if (e.commandName == "FrameSelected")
{
SceneView.lastActiveSceneView.LookAt(followTarget.transform.position);
e.Use();
}
else if (e.commandName == "FrameSelectedWithLock")
{
Selection.objects = new Object[] { followTarget.gameObject, Script.gameObject };
SceneView.lastActiveSceneView.FrameSelected(true);
e.Use();
}
}
}
/////////////////////////////////////////////////
////////// LOOKAT TARGET DETERMINATION //////////
/////////////////////////////////////////////////
public BaseVehicleDriver GetBestLookAtVehicle(BaseVehicleDriver[] targetVehicles)
{
BaseVehicleDriver bestLookAtVehicle = null;
float highestPriority = -1;
float targetPriority;
foreach (BaseVehicleDriver targetVehicle in targetVehicles)
{
targetPriority = -1;
Vector2 relativePositionOnTrack = TrackHelper.GetRelativePosition2D(targetVehicle, followVehicle);
float relativeAngleDot = TrackHelper.GetRelativeAngleDot(relativePositionOnTrack);
if (InCameraArea(relativePositionOnTrack, relativeAngleDot))
{
targetPriority = GetTargetingPriority(relativePositionOnTrack.y, relativeAngleDot);
}
if (targetPriority > highestPriority)
{
bestLookAtVehicle = targetVehicle;
highestPriority = targetPriority;
}
}
return(bestLookAtVehicle);
}
private void FindTarget()
{
target = FindObjectOfType <PlayerVehicleDriver>();
#if UNITY_EDITOR
UnityEditor.EditorUtility.SetDirty(this);
#endif
}
/// <summary>
/// Returns the quadrant of the target vehicle on the track relative to the origin vehicle.
/// </summary>
public static RelativeQuadrant GetRelativeQuadrant(BaseVehicleDriver targetDriver, BaseVehicleDriver originDriver)
{
Vector2 relativePosition = GetRelativePosition2D(targetDriver, originDriver);
RelativeDirection relativeX = relativePosition.x < 0f ? RelativeDirection.Left : RelativeDirection.Right;
RelativeDirection relativeZ = relativePosition.y < 0f ? RelativeDirection.Back : RelativeDirection.Front;
RelativeQuadrant quadrant = (RelativeQuadrant)(relativeX | relativeZ);
return(quadrant);
}
/// <summary>
/// Returns the best available camera to frame the target vehicle.
/// </summary>
public MountedCamera GetBestCamera(BaseVehicleDriver targetVehicle)
{
if (targetVehicle == null)
{
return(GetRandomFrontFacingCamera());
}
#if UNITY_EDITOR
LookAtVehicle = targetVehicle;
#endif
RelativeQuadrant quadrant = TrackHelper.GetRelativeQuadrant(targetVehicle, followVehicle);
return(WeightedRandom.Get(GetQuadrantCameras(quadrant)));
}
/// <summary>
/// Returns the best available lookat vehicle for the given rig.
/// </summary>
/// <param name="rig">The rig from which the lookat vehicle is viewed.</param>
private static BaseVehicleDriver GetBestLookAtVehicle(MountedCameraRig rig)
{
BaseVehicleDriver lookAtVehicle = null;
BaseVehicleDriver[] availableVehicles = WorldObjectManager.Instance.Drivers;
if (rig.FollowVehicle == null)
{
lookAtVehicle = ListHelper.GetRandomValue(availableVehicles);
}
else
{
lookAtVehicle = rig.GetBestLookAtVehicle(availableVehicles);
}
return(lookAtVehicle);
}
/// <summary>
/// Returns the relative offset of the target from the origin on the track.
/// X = relative horizontal offset, Y = relative distance along track.
/// </summary>
public static Vector2 GetRelativePosition2D(BaseVehicleDriver targetVehicle, BaseVehicleDriver originVehicle)
{
if (targetVehicle?.Controller == null || originVehicle?.Controller == null)
{
return(new Vector2(Mathf.Infinity, Mathf.Infinity));
}
Vector3 originPosition = new Vector3(originVehicle.Controller.ClosestPathDistanceToPoint, 0f, originVehicle.Controller.ClosestPathDistanceTraveled);
Vector3 targetPosition = new Vector3(targetVehicle.Controller.ClosestPathDistanceToPoint, 0f, targetVehicle.Controller.ClosestPathDistanceTraveled);
float totalTrackDistance = 1f / targetVehicle.PathProgress * targetPosition.z;
// Get shortest relative distance along track in case shortest path crosses the finish line.
Vector3 relativeDistance = targetPosition - originPosition;
float inverseRelativeZ = (totalTrackDistance - Mathf.Abs(relativeDistance.z)) * -Mathf.Sign(relativeDistance.z);
float shortestRelativeZ = Mathf.Abs(relativeDistance.z) < Mathf.Abs(inverseRelativeZ) ? relativeDistance.z : inverseRelativeZ;
return(new Vector2(relativeDistance.x, shortestRelativeZ));
}
/// <summary>
/// Returns the best available follow vehicle to frame the given lookat vehicle.
/// </summary>
/// <param name="lookAtVehicle">The object that needs to be in view. Pass null to get a random follow vehicle.</param>
private static BaseVehicleDriver GetBestFollowVehicle(BaseVehicleDriver lookAtVehicle)
{
BaseVehicleDriver followVehicle = null;
BaseVehicleDriver[] availableVehicles = WorldObjectManager.Instance.Drivers;
if (lookAtVehicle == null)
{
followVehicle = ListHelper.GetRandomValue(availableVehicles);
}
else
{
// TODO: Replace with best follow vehicle determination.
// Can be done by comparing the priority of the lookAtVehicle generated by a rig on each followVehicle in range.
followVehicle = ListHelper.GetRandomValue(availableVehicles);
}
return(followVehicle);
}
/// <summary>
/// Returns the relative offset of the target from the origin on the track.
/// X = relative horizontal offset, Z = relative distance along track.
/// </summary>
public static Vector3 GetRelativePosition3D(BaseVehicleDriver targetVehicle, BaseVehicleDriver originVehicle)
{
Vector2 relativeDriverPosition = GetRelativePosition2D(targetVehicle, originVehicle);
return(new Vector3(relativeDriverPosition.x, 0, relativeDriverPosition.y));
}
public CinematicCamera GetBestMountedCamera(BaseVehicleDriver followVehicle, BaseVehicleDriver lookAtVehicle)
{
return(MountedCameraDirector.Instance.GetBestMountedCamera(followVehicle, lookAtVehicle));
}
/// <summary>
/// Returns the best available camera for the given follow and lookat vehicles.
/// </summary>
/// <param name="followVehicle">The vehicle the camera will be mounted to. Pass null to determine the best follow vehicle for the given lookat vehicle automatically.</param>
/// <param name="lookAtVehicle">The vehicle that needs to be in view. Pass null to determine the best lookat vehicle for the given follow vehicle automatically.</param>
public MountedCamera GetBestMountedCamera(BaseVehicleDriver followVehicle, BaseVehicleDriver lookAtVehicle)
{
rig.FollowVehicle = followVehicle ?? GetBestFollowVehicle(lookAtVehicle);
return(rig.GetBestCamera(lookAtVehicle ?? GetBestLookAtVehicle(rig)));
}
