1081 lines
48 KiB
C#
1081 lines
48 KiB
C#
|
/// ---------------------------------------------
|
|||
|
|
/// Ultimate Character Controller
|
|||
|
|
/// Copyright (c) Opsive. All Rights Reserved.
|
|||
|
|
/// https://www.opsive.com
|
|||
|
|
/// ---------------------------------------------
|
|||
|
|
|
|||
|
|
namespace Opsive.UltimateCharacterController.Game
|
|||
|
|
{
|
|||
|
|
using Opsive.Shared.Events;
|
|||
|
|
using Opsive.Shared.Game;
|
|||
|
|
using Opsive.Shared.Utility;
|
|||
|
|
using Opsive.UltimateCharacterController.Camera;
|
|||
|
|
using Opsive.UltimateCharacterController.Character;
|
|||
|
|
using Opsive.UltimateCharacterController.Utility;
|
|||
|
|
using UnityEngine;
|
|||
|
|
using UnityEngine.SceneManagement;
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The KinematicObjectManager acts as a central organizer for determining when the characters, cameras, and kinematic objects should update. The update order that the objects
|
|||
|
|
/// are updated matter and the KinematicObjectManager ensures the objects are updated in the correct order to allow for smooth movement.
|
|||
|
|
/// </summary>
|
|||
|
|
public class KinematicObjectManager : MonoBehaviour
|
|||
|
|
{
|
|||
|
|
/// <summary>
|
|||
|
|
/// Specifies the location that the object should be updated.
|
|||
|
|
/// </summary>
|
|||
|
|
public enum UpdateLocation
|
|||
|
|
{
|
|||
|
|
Update, // The object will be updated within Unity's Update loop.
|
|||
|
|
FixedUpdate, // The object will be updated within Unity's FixedUpdate loop.
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// A small storage class used for storing the fixed and smooth location. This component will also move the interpolate the objects during the Update loop.
|
|||
|
|
/// </summary>
|
|||
|
|
private class SmoothFixedLocation
|
|||
|
|
{
|
|||
|
|
private Transform m_Transform;
|
|||
|
|
|
|||
|
|
private Vector3 m_FixedPosition;
|
|||
|
|
private Quaternion m_FixedRotation;
|
|||
|
|
private Vector3 m_SmoothPosition;
|
|||
|
|
private Quaternion m_SmoothRotation;
|
|||
|
|
|
|||
|
|
public Transform Transform { get { return m_Transform; } }
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Initializes the object.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="transform">The transform that is being managed by the KinematicObjectManager.</param>
|
|||
|
|
public void Initialize(Transform transform)
|
|||
|
|
{
|
|||
|
|
m_Transform = transform;
|
|||
|
|
|
|||
|
|
m_FixedPosition = m_SmoothPosition = m_Transform.position;
|
|||
|
|
m_FixedRotation = m_SmoothRotation = m_Transform.rotation;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The object is moved within FixedUpdate while the camera is moved within Update. This would normally cause jitters but a separate smooth variable
|
|||
|
|
/// ensures the object stays in synchronize with the Update loop.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="interpAmount">The amount to interpolate between the smooth and fixed position.</param>
|
|||
|
|
public virtual void SmoothMove(float interpAmount)
|
|||
|
|
{
|
|||
|
|
m_Transform.position = Vector3.Lerp(m_SmoothPosition, m_FixedPosition, interpAmount);
|
|||
|
|
m_Transform.rotation = Quaternion.Slerp(m_SmoothRotation, m_FixedRotation, interpAmount);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Restores the location back to the fixed location. This will be performed immediately before the object is moved within FixedUpdate.
|
|||
|
|
/// </summary>
|
|||
|
|
public virtual void RestoreFixedLocation()
|
|||
|
|
{
|
|||
|
|
m_Transform.position = m_SmoothPosition = m_FixedPosition;
|
|||
|
|
m_Transform.rotation = m_SmoothRotation = m_FixedRotation;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Assigns the fixed location. This will be performed immediately after the object is moved within FixedUpdate.
|
|||
|
|
/// </summary>
|
|||
|
|
public virtual void AssignFixedLocation()
|
|||
|
|
{
|
|||
|
|
m_FixedPosition = m_Transform.position;
|
|||
|
|
m_FixedRotation = m_Transform.rotation;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Immediately set the object's position.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
public virtual void SetPosition(Vector3 position)
|
|||
|
|
{
|
|||
|
|
m_Transform.position = m_FixedPosition = m_SmoothPosition = position;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Immediately set the object's rotation.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="position">The rotation of the object.</param>
|
|||
|
|
public virtual void SetRotation(Quaternion rotation)
|
|||
|
|
{
|
|||
|
|
m_Transform.rotation = m_FixedRotation = m_SmoothRotation = rotation;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Extends the SmoothFixedLocation class for characters.
|
|||
|
|
/// </summary>
|
|||
|
|
private class KinematicCharacter : SmoothFixedLocation
|
|||
|
|
{
|
|||
|
|
private UltimateCharacterLocomotion m_CharacterLocomotion;
|
|||
|
|
private UltimateCharacterLocomotionHandler m_CharacterHandler;
|
|||
|
|
private CharacterIKBase m_CharacterIK;
|
|||
|
|
private SmoothFixedLocation[] m_SmoothedBones;
|
|||
|
|
private CameraController m_AttachedCamera;
|
|||
|
|
private float m_HorizontalMovement;
|
|||
|
|
private float m_ForwardMovement;
|
|||
|
|
private float m_DeltaYawRotation;
|
|||
|
|
private ScheduledEventBase m_CompleteInitEvent;
|
|||
|
|
|
|||
|
|
public UltimateCharacterLocomotion CharacterLocomotion { get { return m_CharacterLocomotion; } }
|
|||
|
|
public CameraController AttachedCamera { get { return m_AttachedCamera; } }
|
|||
|
|
public CharacterIKBase CharacterIK { get { return m_CharacterIK; } }
|
|||
|
|
public float HorizontalMovement { set { m_HorizontalMovement = value; } }
|
|||
|
|
public float ForwardMovement { set { m_ForwardMovement = value; } }
|
|||
|
|
public float DeltaYawRotation { set { m_DeltaYawRotation = value; } }
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Initializes the object.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterLocomotion">The character that is being managed by the KinematicObjectManager.</param>
|
|||
|
|
public void Initialize(UltimateCharacterLocomotion characterLocomotion)
|
|||
|
|
{
|
|||
|
|
m_CharacterLocomotion = characterLocomotion;
|
|||
|
|
|
|||
|
|
OnAttachLookSource(m_CharacterLocomotion.LookSource);
|
|||
|
|
EventHandler.RegisterEvent<ILookSource>(m_CharacterLocomotion.gameObject, "OnCharacterAttachLookSource", OnAttachLookSource);
|
|||
|
|
|
|||
|
|
// The class is pooled so reset any variables.
|
|||
|
|
m_HorizontalMovement = m_ForwardMovement = m_DeltaYawRotation = 0;
|
|||
|
|
Initialize(characterLocomotion.transform);
|
|||
|
|
|
|||
|
|
m_CharacterHandler = m_CharacterLocomotion.GetComponent<UltimateCharacterLocomotionHandler>();
|
|||
|
|
m_CharacterIK = m_CharacterLocomotion.GetComponent<CharacterIKBase>();
|
|||
|
|
|
|||
|
|
// Wait a moment before finishing with the initialization. This allows the character to be created at runtime.
|
|||
|
|
m_CompleteInitEvent = Scheduler.ScheduleFixed(Time.fixedDeltaTime / 2, () => {
|
|||
|
|
if (m_CharacterHandler == null) {
|
|||
|
|
m_CharacterHandler = m_CharacterLocomotion.GetComponent<UltimateCharacterLocomotionHandler>();
|
|||
|
|
}
|
|||
|
|
if (m_CharacterIK == null) {
|
|||
|
|
m_CharacterIK = m_CharacterLocomotion.GetComponent<CharacterIKBase>();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var smoothedBones = m_CharacterLocomotion.SmoothedBones;
|
|||
|
|
if (smoothedBones != null && smoothedBones.Length > 0) {
|
|||
|
|
var validBones = 0;
|
|||
|
|
for (int i = 0; i < smoothedBones.Length; ++i) {
|
|||
|
|
if (smoothedBones[i] != null) {
|
|||
|
|
validBones++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (validBones > 0) {
|
|||
|
|
m_SmoothedBones = new SmoothFixedLocation[validBones];
|
|||
|
|
var index = 0;
|
|||
|
|
for (int i = 0; i < smoothedBones.Length; ++i) {
|
|||
|
|
if (smoothedBones[i] == null) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
m_SmoothedBones[index] = GenericObjectPool.Get<SmoothFixedLocation>();
|
|||
|
|
m_SmoothedBones[index].Initialize(smoothedBones[i]);
|
|||
|
|
index++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
m_CompleteInitEvent = null;
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// A new ILookSource object has been attached to the character.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="lookSource">The ILookSource object attached to the character.</param>
|
|||
|
|
private void OnAttachLookSource(ILookSource lookSource)
|
|||
|
|
{
|
|||
|
|
if (lookSource != null) {
|
|||
|
|
m_AttachedCamera = lookSource.GameObject.GetCachedComponent<CameraController>();
|
|||
|
|
} else {
|
|||
|
|
m_AttachedCamera = null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The object is moved within FixedUpdate while the camera is moved within Update. This would normally cause jitters but a separate smooth variable
|
|||
|
|
/// ensures the object stays in synchronize with the Update loop.
|
|||
|
|
/// </summary>
|
|||
|
|
public override void SmoothMove(float interpAmount)
|
|||
|
|
{
|
|||
|
|
if (m_CharacterLocomotion.ManualMove) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
base.SmoothMove(interpAmount);
|
|||
|
|
|
|||
|
|
if (m_SmoothedBones != null) {
|
|||
|
|
for (int i = 0; i < m_SmoothedBones.Length; ++i) {
|
|||
|
|
m_SmoothedBones[i].SmoothMove(interpAmount);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Moves the character according to the input variables.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="manualMove">Is the character being moved manually?</param>
|
|||
|
|
public void Move(bool manualMove)
|
|||
|
|
{
|
|||
|
|
if (m_CharacterLocomotion.ManualMove != manualMove) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_CharacterHandler != null) {
|
|||
|
|
m_DeltaYawRotation = m_CharacterHandler.GetDeltaYawRotation();
|
|||
|
|
}
|
|||
|
|
m_CharacterLocomotion.Move(m_HorizontalMovement, m_ForwardMovement, m_DeltaYawRotation);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Restores the location back to the fixed location. This will be performed immediately before the object is moved within FixedUpdate.
|
|||
|
|
/// </summary>
|
|||
|
|
public override void RestoreFixedLocation()
|
|||
|
|
{
|
|||
|
|
base.RestoreFixedLocation();
|
|||
|
|
|
|||
|
|
if (m_SmoothedBones != null) {
|
|||
|
|
for (int i = 0; i < m_SmoothedBones.Length; ++i) {
|
|||
|
|
m_SmoothedBones[i].RestoreFixedLocation();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Assigns the fixed location. This will be performed immediately after the object is moved within FixedUpdate.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="assignSmoothedBones">Should the character's smoothed bones be assigned?</param>
|
|||
|
|
public void AssignFixedLocation(bool assignSmoothedBones)
|
|||
|
|
{
|
|||
|
|
if (assignSmoothedBones) {
|
|||
|
|
if (m_SmoothedBones != null) {
|
|||
|
|
for (int i = 0; i < m_SmoothedBones.Length; ++i) {
|
|||
|
|
m_SmoothedBones[i].AssignFixedLocation();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
base.AssignFixedLocation();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Immediately set the object's position.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
public override void SetPosition(Vector3 position)
|
|||
|
|
{
|
|||
|
|
base.SetPosition(position);
|
|||
|
|
|
|||
|
|
// The character's position has been set. Reset the bone location so they will snap into place.
|
|||
|
|
if (m_SmoothedBones != null) {
|
|||
|
|
for (int i = 0; i < m_SmoothedBones.Length; ++i) {
|
|||
|
|
m_SmoothedBones[i].SetPosition(m_SmoothedBones[i].Transform.position);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Immediately set the object's rotation.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="rotation">The rotation of the object.</param>
|
|||
|
|
public override void SetRotation(Quaternion rotation)
|
|||
|
|
{
|
|||
|
|
base.SetRotation(rotation);
|
|||
|
|
|
|||
|
|
// The character's rotation has been set. Reset the bone location so they will snap into place.
|
|||
|
|
if (m_SmoothedBones != null) {
|
|||
|
|
for (int i = 0; i < m_SmoothedBones.Length; ++i) {
|
|||
|
|
m_SmoothedBones[i].SetRotation(m_SmoothedBones[i].Transform.rotation);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Stops managing the character.
|
|||
|
|
/// </summary>
|
|||
|
|
public void UnregisterCharacter()
|
|||
|
|
{
|
|||
|
|
if (m_CompleteInitEvent != null) {
|
|||
|
|
Scheduler.Cancel(m_CompleteInitEvent);
|
|||
|
|
m_CompleteInitEvent = null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_SmoothedBones != null) {
|
|||
|
|
for (int i = 0; i < m_SmoothedBones.Length; ++i) {
|
|||
|
|
GenericObjectPool.Return(m_SmoothedBones[i]);
|
|||
|
|
}
|
|||
|
|
m_SmoothedBones = null;
|
|||
|
|
}
|
|||
|
|
EventHandler.UnregisterEvent<ILookSource>(m_CharacterLocomotion.gameObject, "OnCharacterAttachLookSource", OnAttachLookSource);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Extends the SmoothFixedLocation class for kinematic objects.
|
|||
|
|
/// </summary>
|
|||
|
|
private class KinematicObject : SmoothFixedLocation
|
|||
|
|
{
|
|||
|
|
private IKinematicObject m_KinematicObject;
|
|||
|
|
|
|||
|
|
public IKinematicObject IKinematicObject { get { return m_KinematicObject; } }
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Initializes the object.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="kinematicObject">The kinematic object that is being managed by the KinematicObjectManager.</param>
|
|||
|
|
public void Initialize(IKinematicObject kinematicObject)
|
|||
|
|
{
|
|||
|
|
m_KinematicObject = kinematicObject;
|
|||
|
|
Initialize(m_KinematicObject.transform);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Moves the kinematic object.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="applyFixedLocation">Should the fixed location be applied?</param>
|
|||
|
|
public void Move(bool applyFixedLocation)
|
|||
|
|
{
|
|||
|
|
if (applyFixedLocation) {
|
|||
|
|
RestoreFixedLocation();
|
|||
|
|
}
|
|||
|
|
m_KinematicObject.Move();
|
|||
|
|
if (applyFixedLocation) {
|
|||
|
|
AssignFixedLocation();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Moves and rotates the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
private class KinematicCamera : SmoothFixedLocation
|
|||
|
|
{
|
|||
|
|
private CameraController m_CameraController;
|
|||
|
|
private UltimateCharacterLocomotion m_CharacterLocomotion;
|
|||
|
|
private Vector2 m_LookVector;
|
|||
|
|
|
|||
|
|
public CameraController CameraController { get { return m_CameraController; } }
|
|||
|
|
public UltimateCharacterLocomotion CharacterLocomotion { get { return m_CharacterLocomotion; } }
|
|||
|
|
public Vector2 LookVector { set { m_LookVector = value; } }
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Initializes the object.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="cameraController">The camera controller that is being managed by the KinematicObjectManager.</param>
|
|||
|
|
public void Initialize(CameraController cameraController)
|
|||
|
|
{
|
|||
|
|
Initialize(cameraController.transform);
|
|||
|
|
|
|||
|
|
m_CameraController = cameraController;
|
|||
|
|
OnAttachCharacter(m_CameraController.Character);
|
|||
|
|
EventHandler.RegisterEvent<GameObject>(m_CameraController.gameObject, "OnCameraAttachCharacter", OnAttachCharacter);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attaches the camera to the specified character.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="character">The character to attach the camera to.</param>
|
|||
|
|
private void OnAttachCharacter(GameObject character)
|
|||
|
|
{
|
|||
|
|
if (character != null) {
|
|||
|
|
m_CharacterLocomotion = character.GetCachedComponent<UltimateCharacterLocomotion>();
|
|||
|
|
} else {
|
|||
|
|
m_CharacterLocomotion = null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Rotates the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
public void Rotate()
|
|||
|
|
{
|
|||
|
|
RestoreFixedLocation();
|
|||
|
|
|
|||
|
|
m_CameraController.Rotate(m_LookVector.x, m_LookVector.y);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Calls the Move method of the CameraController.
|
|||
|
|
/// </summary>
|
|||
|
|
public void Move()
|
|||
|
|
{
|
|||
|
|
m_CameraController.Move(m_LookVector.x, m_LookVector.y);
|
|||
|
|
|
|||
|
|
AssignFixedLocation();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Stops managing the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
public void UnregisterCamera()
|
|||
|
|
{
|
|||
|
|
EventHandler.UnregisterEvent<GameObject>(m_CameraController.gameObject, "OnCameraAttachCharacter", OnAttachCharacter);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private static KinematicObjectManager s_Instance;
|
|||
|
|
private static KinematicObjectManager Instance
|
|||
|
|
{
|
|||
|
|
get
|
|||
|
|
{
|
|||
|
|
if (!s_Initialized) {
|
|||
|
|
s_Instance = new GameObject("Kinematic Object Manager").AddComponent<KinematicObjectManager>();
|
|||
|
|
s_Initialized = true;
|
|||
|
|
}
|
|||
|
|
return s_Instance;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
private static bool s_Initialized;
|
|||
|
|
|
|||
|
|
[Tooltip("The number of starting characters. For best performance this value should be the maximum number of characters that can be active within the scene.")]
|
|||
|
|
[SerializeField] protected int m_StartCharacterCount = 1;
|
|||
|
|
[Tooltip("The number of starting cameras. For best performance this value should be the maximum number of cameras that can be active within the scene.")]
|
|||
|
|
[SerializeField] protected int m_StartCameraCount = 1;
|
|||
|
|
[UnityEngine.Serialization.FormerlySerializedAs("m_StartDeterministicObjectCount")]
|
|||
|
|
[Tooltip("The number of starting kinematic objects. For best performance this value should be the maximum number of kinematic objects that can be active within the scene.")]
|
|||
|
|
[SerializeField] protected int m_StartKinematicObjectCount;
|
|||
|
|
[Tooltip("Should the Auto Sync Transforms be enabled? See this page for more info: https://docs.unity3d.com/ScriptReference/Physics-autoSyncTransforms.html.")]
|
|||
|
|
[SerializeField] protected bool m_AutoSyncTransforms;
|
|||
|
|
|
|||
|
|
public int StartCharacterCount { get { return m_StartCharacterCount; } }
|
|||
|
|
public int StartCameraCount { get { return m_StartCameraCount; } }
|
|||
|
|
public int StartKinematicObjectCount { get { return m_StartKinematicObjectCount; } }
|
|||
|
|
|
|||
|
|
private KinematicCharacter[] m_Characters;
|
|||
|
|
private KinematicCamera[] m_Cameras;
|
|||
|
|
private KinematicObject[] m_KinematicObjects;
|
|||
|
|
private int m_CharacterCount;
|
|||
|
|
private int m_CameraCount;
|
|||
|
|
private int m_KinematicObjectCount;
|
|||
|
|
private float m_FixedTime;
|
|||
|
|
private bool m_FixedUpdate;
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The object has been enabled.
|
|||
|
|
/// </summary>
|
|||
|
|
private void OnEnable()
|
|||
|
|
{
|
|||
|
|
// The object may have been enabled outside of the scene unloading.
|
|||
|
|
if (s_Instance == null) {
|
|||
|
|
s_Instance = this;
|
|||
|
|
s_Initialized = true;
|
|||
|
|
SceneManager.sceneUnloaded -= SceneUnloaded;
|
|||
|
|
|
|||
|
|
// Characters and cameras may be marked DontDestroyOnLoad. Reregister any active objects.
|
|||
|
|
var characterLocomotions = FindObjectsOfType<UltimateCharacterLocomotion>();
|
|||
|
|
for (int i = 0; i < characterLocomotions.Length; ++i) {
|
|||
|
|
if (characterLocomotions[i].KinematicObjectIndex == -1) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
// The character is active.
|
|||
|
|
characterLocomotions[i].KinematicObjectIndex = RegisterCharacter(characterLocomotions[i]);
|
|||
|
|
}
|
|||
|
|
var cameras = FindObjectsOfType<CameraController>();
|
|||
|
|
for (int i = 0; i < cameras.Length; ++i) {
|
|||
|
|
if (cameras[i].KinematicObjectIndex == -1) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
// The camera is active.
|
|||
|
|
cameras[i].KinematicObjectIndex = RegisterCamera(cameras[i]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Initialize the default values.
|
|||
|
|
/// </summary>
|
|||
|
|
private void Awake()
|
|||
|
|
{
|
|||
|
|
m_Characters = new KinematicCharacter[m_StartCharacterCount];
|
|||
|
|
m_Cameras = new KinematicCamera[m_StartCameraCount];
|
|||
|
|
m_KinematicObjects = new KinematicObject[m_StartKinematicObjectCount];
|
|||
|
|
|
|||
|
|
Physics.autoSyncTransforms = m_AutoSyncTransforms;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Registers the character to be managed by the KinematicObjectManager.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterLocomotion">The character that should be managed by the KinematicObjectManager.</param>
|
|||
|
|
/// <returns>The index of the character registered.</returns>
|
|||
|
|
public static int RegisterCharacter(UltimateCharacterLocomotion characterLocomotion)
|
|||
|
|
{
|
|||
|
|
return Instance.RegisterCharacterInternal(characterLocomotion);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which registers the character to be managed by the KinematicObjectManager.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterLocomotion">The character that should be managed by the KinematicObjectManager.</param>
|
|||
|
|
/// <returns>The index of the character registered.</returns>
|
|||
|
|
private int RegisterCharacterInternal(UltimateCharacterLocomotion characterLocomotion)
|
|||
|
|
{
|
|||
|
|
if (m_CharacterCount == m_Characters.Length) {
|
|||
|
|
System.Array.Resize(ref m_Characters, m_Characters.Length + 1);
|
|||
|
|
Debug.LogWarning($"Characters array resized. For best performance increase the size of the Start Character Count variable " +
|
|||
|
|
$"within the Kinematic Object Manager to a value of at least {(m_CharacterCount + 1)}.");
|
|||
|
|
}
|
|||
|
|
m_Characters[m_CharacterCount] = GenericObjectPool.Get<KinematicCharacter>();
|
|||
|
|
m_Characters[m_CharacterCount].Initialize(characterLocomotion);
|
|||
|
|
m_CharacterCount++;
|
|||
|
|
return m_CharacterCount - 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Registers the camera to be managed by the KinematicObjectManager.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="cameraController">The camera that should be managed by the KinematicObjectManager.</param>
|
|||
|
|
/// <returns>The index of the camera registered.</returns>
|
|||
|
|
public static int RegisterCamera(CameraController cameraController)
|
|||
|
|
{
|
|||
|
|
return Instance.RegisterCameraInternal(cameraController);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Intenral method which registers the camera to be managed by the KinematicObjectManager.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="cameraController">The camera that should be managed by the KinematicObjectManager.</param>
|
|||
|
|
/// <returns>The index of the camera registered.</returns>
|
|||
|
|
private int RegisterCameraInternal(CameraController cameraController)
|
|||
|
|
{
|
|||
|
|
if (m_CameraCount == m_Cameras.Length) {
|
|||
|
|
System.Array.Resize(ref m_Cameras, m_Cameras.Length + 1);
|
|||
|
|
Debug.LogWarning($"Cameras array resized. For best performance increase the size of the Start Camera Count variable " +
|
|||
|
|
$"within the Kinematic Object Manager to a value of at least {(m_CameraCount + 1)}.");
|
|||
|
|
}
|
|||
|
|
m_Cameras[m_CameraCount] = GenericObjectPool.Get<KinematicCamera>();
|
|||
|
|
m_Cameras[m_CameraCount].Initialize(cameraController);
|
|||
|
|
m_CameraCount++;
|
|||
|
|
return m_CameraCount - 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Registers the kinematic object that should be managed by the KinematicObjectManager.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="kinematicObject">The kinematic object that should be managed by the KinematicObjectManager.</param>
|
|||
|
|
/// <returns>The index of the kinematci object registered.</returns>
|
|||
|
|
public static int RegisterKinematicObject(IKinematicObject kinematicObject)
|
|||
|
|
{
|
|||
|
|
return Instance.RegisterKinematicObjectInternal(kinematicObject);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which registers the kinematic object that should be managed by the KinematicObjectManager.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="kinematicObject">The kinematic object that should be managed by the KinematicObjectManager.</param>
|
|||
|
|
/// <returns>The index of the kinematci object registered.</returns>
|
|||
|
|
private int RegisterKinematicObjectInternal(IKinematicObject kinematicObject)
|
|||
|
|
{
|
|||
|
|
if (m_KinematicObjectCount == m_KinematicObjects.Length) {
|
|||
|
|
System.Array.Resize(ref m_KinematicObjects, m_KinematicObjects.Length + 1);
|
|||
|
|
Debug.LogWarning($"Kinematic objects array resized. For best performance increase the size of the Start Kinematic Object Count variable " +
|
|||
|
|
$"within the Kinematic Object Manager to a value of at least {(m_KinematicObjectCount + 1)}.");
|
|||
|
|
}
|
|||
|
|
m_KinematicObjects[m_KinematicObjectCount] = GenericObjectPool.Get<KinematicObject>();
|
|||
|
|
m_KinematicObjects[m_KinematicObjectCount].Initialize(kinematicObject);
|
|||
|
|
m_KinematicObjectCount++;
|
|||
|
|
return m_KinematicObjectCount - 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sets the yaw rotation of the character.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="yawRotation">The yaw rotation that the character should rotate towards.</param>
|
|||
|
|
public static void SetCharacterDeltaYawRotation(int characterIndex, float yawRotation)
|
|||
|
|
{
|
|||
|
|
Instance.SetCharacterDeltaYawRotationInternal(characterIndex, yawRotation);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which sets the yaw rotation of the character.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="yawRotation">The yaw rotation that the character should rotate towards.</param>
|
|||
|
|
private void SetCharacterDeltaYawRotationInternal(int characterIndex, float yawRotation)
|
|||
|
|
{
|
|||
|
|
m_Characters[characterIndex].DeltaYawRotation = yawRotation;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sets the horizontal and forward input values of the character.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="horizontalMovement">-1 to 1 value specifying the amount of horizontal movement.</param>
|
|||
|
|
/// <param name="forwardMovement">-1 to 1 value specifying the amount of forward movement.</param>
|
|||
|
|
public static void SetCharacterMovementInput(int characterIndex, float horizontalMovement, float forwardMovement)
|
|||
|
|
{
|
|||
|
|
Instance.SetCharacterMovementInputInternal(characterIndex, horizontalMovement, forwardMovement);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which sets the horizontal and forward input values of the character.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="horizontalMovement">-1 to 1 value specifying the amount of horizontal movement.</param>
|
|||
|
|
/// <param name="forwardMovement">-1 to 1 value specifying the amount of forward movement.</param>
|
|||
|
|
private void SetCharacterMovementInputInternal(int characterIndex, float horizontalMovement, float forwardMovement)
|
|||
|
|
{
|
|||
|
|
m_Characters[characterIndex].HorizontalMovement = horizontalMovement;
|
|||
|
|
m_Characters[characterIndex].ForwardMovement = forwardMovement;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Immediately sets the character's position.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
public static void SetCharacterPosition(int characterIndex, Vector3 position)
|
|||
|
|
{
|
|||
|
|
Instance.SetCharacterPositionInternal(characterIndex, position);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which immediately sets the character's position.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
private void SetCharacterPositionInternal(int characterIndex, Vector3 position)
|
|||
|
|
{
|
|||
|
|
m_Characters[characterIndex].SetPosition(position);
|
|||
|
|
|
|||
|
|
if (!m_AutoSyncTransforms) {
|
|||
|
|
Physics.SyncTransforms();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Immediately sets the character's rotation.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
public static void SetCharacterRotation(int characterIndex, Quaternion rotation)
|
|||
|
|
{
|
|||
|
|
Instance.SetCharacterRotationInternal(characterIndex, rotation);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which immediately sets the character's rotation.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
private void SetCharacterRotationInternal(int characterIndex, Quaternion rotation)
|
|||
|
|
{
|
|||
|
|
m_Characters[characterIndex].SetRotation(rotation);
|
|||
|
|
|
|||
|
|
if (!m_AutoSyncTransforms) {
|
|||
|
|
Physics.SyncTransforms();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sets the look vector of the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="cameraIndex">The index of the camera within the cameras array.</param>
|
|||
|
|
/// <param name="lookVector">The look vector of the camera.</param>
|
|||
|
|
public static void SetCameraLookVector(int cameraIndex, Vector2 lookVector)
|
|||
|
|
{
|
|||
|
|
Instance.SetCameraLookVectorInternal(cameraIndex, lookVector);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which sets the look vector of the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="cameraIndex">The index of the camera within the cameras array.</param>
|
|||
|
|
/// <param name="lookVector">The look vector of the camera.</param>
|
|||
|
|
private void SetCameraLookVectorInternal(int cameraIndex, Vector2 lookVector)
|
|||
|
|
{
|
|||
|
|
m_Cameras[cameraIndex].LookVector = lookVector;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sets the position of the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="cameraIndex">The index of the camera within the cameras array.</param>
|
|||
|
|
/// <param name="position">The position of the camera.</param>
|
|||
|
|
public static void SetCameraPosition(int cameraIndex, Vector3 position)
|
|||
|
|
{
|
|||
|
|
Instance.SetCameraPositionInternal(cameraIndex, position);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which sets the position of the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="cameraIndex">The index of the camera within the cameras array.</param>
|
|||
|
|
/// <param name="position">The position of the camera.</param>
|
|||
|
|
private void SetCameraPositionInternal(int cameraIndex, Vector3 position)
|
|||
|
|
{
|
|||
|
|
m_Cameras[cameraIndex].SetPosition(position);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Sets the rotation of the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="cameraIndex">The index of the camera within the cameras array.</param>
|
|||
|
|
/// <param name="rotation">The rotation of the camera.</param>
|
|||
|
|
public static void SetCameraRotation(int cameraIndex, Quaternion rotation)
|
|||
|
|
{
|
|||
|
|
Instance.SetCameraRotationInternal(cameraIndex, rotation);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which sets the rotation of the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="cameraIndex">The index of the camera within the cameras array.</param>
|
|||
|
|
/// <param name="rotation">The rotation of the camera.</param>
|
|||
|
|
private void SetCameraRotationInternal(int cameraIndex, Quaternion rotation)
|
|||
|
|
{
|
|||
|
|
m_Cameras[cameraIndex].SetRotation(rotation);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Immediately sets the kinematic object's position.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="kinematicObjectIndex">The index of the kinematic object within the array.</param>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
public static void SetKinematicObjectPosition(int kinematicObjectIndex, Vector3 position)
|
|||
|
|
{
|
|||
|
|
Instance.SetKinematicObjectPositionInternal(kinematicObjectIndex, position);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which immediately sets the kinematic object's position.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
private void SetKinematicObjectPositionInternal(int kinematicObjectIndex, Vector3 position)
|
|||
|
|
{
|
|||
|
|
m_KinematicObjects[kinematicObjectIndex].SetPosition(position);
|
|||
|
|
|
|||
|
|
if (!m_AutoSyncTransforms) {
|
|||
|
|
Physics.SyncTransforms();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Immediately sets the kinematic object's rotation.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="kinematicObjectIndex">The index of the character within the characters array.</param>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
public static void SetKinematicObjectRotation(int kinematicObjectIndex, Quaternion rotation)
|
|||
|
|
{
|
|||
|
|
Instance.SetKinematicObjectRotationInternal(kinematicObjectIndex, rotation);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which immediately sets the kinematic object's rotation.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="kinematicObjectIndex">The index of the kinematic object within the array.</param>
|
|||
|
|
/// <param name="position">The position of the object.</param>
|
|||
|
|
private void SetKinematicObjectRotationInternal(int kinematicObjectIndex, Quaternion rotation)
|
|||
|
|
{
|
|||
|
|
m_KinematicObjects[kinematicObjectIndex].SetRotation(rotation);
|
|||
|
|
|
|||
|
|
if (!m_AutoSyncTransforms) {
|
|||
|
|
Physics.SyncTransforms();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Smoothly moves the objects.
|
|||
|
|
/// </summary>
|
|||
|
|
private void Update()
|
|||
|
|
{
|
|||
|
|
var interpAmount = (Time.time - m_FixedTime) / Time.fixedDeltaTime;
|
|||
|
|
for (int i = 0; i < m_KinematicObjectCount; ++i) {
|
|||
|
|
if (m_KinematicObjects[i].IKinematicObject.UpdateLocation == UpdateLocation.Update) {
|
|||
|
|
m_KinematicObjects[i].Move(false);
|
|||
|
|
m_KinematicObjects[i].AssignFixedLocation();
|
|||
|
|
} else {
|
|||
|
|
m_KinematicObjects[i].SmoothMove(interpAmount);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
// Sync the transforms for IK.
|
|||
|
|
if (m_KinematicObjectCount > 0 && !m_AutoSyncTransforms) {
|
|||
|
|
Physics.SyncTransforms();
|
|||
|
|
}
|
|||
|
|
for (int i = 0; i < m_CameraCount; ++i) {
|
|||
|
|
if (m_Cameras[i].CharacterLocomotion.UpdateLocation == UpdateLocation.Update) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_Cameras[i].SmoothMove(interpAmount);
|
|||
|
|
}
|
|||
|
|
for (int i = 0; i < m_CharacterCount; ++i) {
|
|||
|
|
if (m_Characters[i].CharacterLocomotion.UpdateLocation == UpdateLocation.Update) {
|
|||
|
|
m_Characters[i].Move(false);
|
|||
|
|
m_Characters[i].AssignFixedLocation(false);
|
|||
|
|
m_Characters[i].AssignFixedLocation(true);
|
|||
|
|
} else {
|
|||
|
|
if (m_Characters[i].CharacterIK != null && m_Characters[i].CharacterIK.enabled) {
|
|||
|
|
m_Characters[i].CharacterIK.Move(false);
|
|||
|
|
}
|
|||
|
|
// Update the smoothed bone fixed location after the IK pass has executed. The animator is updated
|
|||
|
|
// during the physics loop so the smooth bone locations only need to be assigned after the FixedUpdate
|
|||
|
|
// loop has run.
|
|||
|
|
if (m_FixedUpdate) {
|
|||
|
|
m_Characters[i].AssignFixedLocation(true);
|
|||
|
|
}
|
|||
|
|
m_Characters[i].SmoothMove(interpAmount);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
m_FixedUpdate = false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Moves the kinematic objects and characters.
|
|||
|
|
/// </summary>
|
|||
|
|
private void FixedUpdate()
|
|||
|
|
{
|
|||
|
|
// The kinematic object and cameras should be moved first so the characters receive the most recent changes.
|
|||
|
|
for (int i = 0; i < m_KinematicObjectCount; ++i) {
|
|||
|
|
if (m_KinematicObjects[i].IKinematicObject.UpdateLocation == UpdateLocation.Update) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
m_KinematicObjects[i].Move(true);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for (int i = 0; i < m_CharacterCount; ++i) {
|
|||
|
|
if (m_Characters[i].CharacterLocomotion.UpdateLocation == UpdateLocation.Update) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
if (!m_AutoSyncTransforms) {
|
|||
|
|
Physics.SyncTransforms();
|
|||
|
|
}
|
|||
|
|
m_Characters[i].Move(false);
|
|||
|
|
if (m_Characters[i].CharacterIK != null && m_Characters[i].CharacterIK.enabled) {
|
|||
|
|
m_Characters[i].CharacterIK.Move(true);
|
|||
|
|
}
|
|||
|
|
// If FixedUpdate is called multiple times before Update then the framerate is low.
|
|||
|
|
// Update the position immediately to prevent jittering.
|
|||
|
|
if (m_FixedUpdate) {
|
|||
|
|
m_Characters[i].AssignFixedLocation(true);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Remember the time so SmoothMove can determine how much interpolation is necessary.
|
|||
|
|
m_FixedTime = Time.time;
|
|||
|
|
m_FixedUpdate = true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Updates the IK component.
|
|||
|
|
/// </summary>
|
|||
|
|
private void LateUpdate()
|
|||
|
|
{
|
|||
|
|
for (int i = 0; i < m_CharacterCount; ++i) {
|
|||
|
|
if (m_Characters[i].CharacterIK != null && m_Characters[i].CharacterIK.enabled) {
|
|||
|
|
m_Characters[i].CharacterIK.Move(false);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Moves the character.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character.</param>
|
|||
|
|
public static void CharacterMove(int characterIndex)
|
|||
|
|
{
|
|||
|
|
Instance.CharacterMoveInternal(characterIndex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which moves the character.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
public void CharacterMoveInternal(int characterIndex)
|
|||
|
|
{
|
|||
|
|
if (characterIndex < 0) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!m_AutoSyncTransforms) {
|
|||
|
|
Physics.SyncTransforms();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_Characters[characterIndex].Move(true);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Indicates that the character has started moving.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
public static void BeginCharacterMovement(int characterIndex)
|
|||
|
|
{
|
|||
|
|
Instance.BeginCharacterMovementInternal(characterIndex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which indicates that the character has started moving.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
private void BeginCharacterMovementInternal(int characterIndex)
|
|||
|
|
{
|
|||
|
|
if (characterIndex < 0) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!m_AutoSyncTransforms) {
|
|||
|
|
Physics.SyncTransforms();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_Characters[characterIndex].CharacterLocomotion.UpdateLocation == UpdateLocation.FixedUpdate) {
|
|||
|
|
m_Characters[characterIndex].RestoreFixedLocation();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// If the character has a camera attached the camera should first be rotated.
|
|||
|
|
int cameraIndex;
|
|||
|
|
if (m_Characters[characterIndex].AttachedCamera != null && (cameraIndex = m_Characters[characterIndex].AttachedCamera.KinematicObjectIndex) >= 0) {
|
|||
|
|
m_Cameras[cameraIndex].Rotate();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Indicates that the character has stopped moving.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
public static void EndCharacterMovement(int characterIndex)
|
|||
|
|
{
|
|||
|
|
Instance.EndCharacterMovementInternal(characterIndex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which indicates that the character has stopped moving.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
private void EndCharacterMovementInternal(int characterIndex)
|
|||
|
|
{
|
|||
|
|
if (characterIndex < 0) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_Characters[characterIndex].CharacterLocomotion.UpdateLocation == UpdateLocation.FixedUpdate) {
|
|||
|
|
m_Characters[characterIndex].AssignFixedLocation();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// After the character has updated the camera should update one more time to account for the new character position.
|
|||
|
|
int cameraIndex;
|
|||
|
|
if (m_Characters[characterIndex].AttachedCamera != null && (cameraIndex = m_Characters[characterIndex].AttachedCamera.KinematicObjectIndex) >= 0) {
|
|||
|
|
m_Cameras[cameraIndex].Move();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Stops managing the object at the specified index.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the object within the manager array.</param>
|
|||
|
|
public static void UnregisterCharacter(int characterIndex)
|
|||
|
|
{
|
|||
|
|
Instance.UnregisterCharacterInternal(characterIndex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which stops managing the character at the specified index.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the character within the characters array.</param>
|
|||
|
|
private void UnregisterCharacterInternal(int characterIndex)
|
|||
|
|
{
|
|||
|
|
if (characterIndex < 0) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_Characters[characterIndex].UnregisterCharacter();
|
|||
|
|
GenericObjectPool.Return(m_Characters[characterIndex]);
|
|||
|
|
// Keep the array packed by shifting all of the subsequent elements over by one.
|
|||
|
|
for (int i = characterIndex + 1; i < m_CharacterCount; ++i) {
|
|||
|
|
m_Characters[i - 1] = m_Characters[i];
|
|||
|
|
m_Characters[i - 1].CharacterLocomotion.KinematicObjectIndex = i - 1;
|
|||
|
|
}
|
|||
|
|
m_CharacterCount--;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Stops managing the camera at the specified index.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the camera within the cameras array.</param>
|
|||
|
|
public static void UnregisterCamera(int cameraIndex)
|
|||
|
|
{
|
|||
|
|
Instance.UnregisterCameraInternal(cameraIndex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which stops managing the camera at the specified index.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="characterIndex">The index of the camera within the cameras array.</param>
|
|||
|
|
private void UnregisterCameraInternal(int cameraIndex)
|
|||
|
|
{
|
|||
|
|
if (cameraIndex < 0) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_Cameras[cameraIndex].UnregisterCamera();
|
|||
|
|
GenericObjectPool.Return(m_Cameras[cameraIndex]);
|
|||
|
|
// Keep the array packed by shifting all of the subsequent elements over by one.
|
|||
|
|
for (int i = cameraIndex + 1; i < m_CameraCount; ++i) {
|
|||
|
|
m_Cameras[i - 1] = m_Cameras[i];
|
|||
|
|
m_Cameras[i - 1].CameraController.KinematicObjectIndex = i - 1;
|
|||
|
|
}
|
|||
|
|
m_CameraCount--;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Stops managing the kinematic object at the specified index.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="kinematicObjectIndex">The index of the kinematic object within the characters array.</param>
|
|||
|
|
public static void UnregisterKinematicObject(int kinematicObjectIndex)
|
|||
|
|
{
|
|||
|
|
Instance.UnregisterKinematicObjectInternal(kinematicObjectIndex);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Internal method which stops managing the kinematic object at the specified index.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="kinematicObjectIndex">The index of the kinematic object within the characters array.</param>
|
|||
|
|
private void UnregisterKinematicObjectInternal(int kinematicObjectIndex)
|
|||
|
|
{
|
|||
|
|
if (kinematicObjectIndex < 0) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
GenericObjectPool.Return(m_KinematicObjects[kinematicObjectIndex]);
|
|||
|
|
// Keep the array packed by shifting all of the subsequent elements over by one.
|
|||
|
|
for (int i = kinematicObjectIndex + 1; i < m_KinematicObjectCount; ++i) {
|
|||
|
|
m_KinematicObjects[i - 1] = m_KinematicObjects[i];
|
|||
|
|
m_KinematicObjects[i - 1].IKinematicObject.KinematicObjectIndex = i - 1;
|
|||
|
|
}
|
|||
|
|
m_KinematicObjectCount--;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Reset the initialized variable when the scene is no longer loaded.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="scene">The scene that was unloaded.</param>
|
|||
|
|
private void SceneUnloaded(Scene scene)
|
|||
|
|
{
|
|||
|
|
s_Initialized = false;
|
|||
|
|
s_Instance = null;
|
|||
|
|
SceneManager.sceneUnloaded -= SceneUnloaded;
|
|||
|
|
|
|||
|
|
UnityEngineUtility.ClearCache();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The object has been disabled.
|
|||
|
|
/// </summary>
|
|||
|
|
private void OnDisable()
|
|||
|
|
{
|
|||
|
|
SceneManager.sceneUnloaded += SceneUnloaded;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#if UNITY_2019_3_OR_NEWER
|
|||
|
|
/// <summary>
|
|||
|
|
/// Reset the static variables for domain reloading.
|
|||
|
|
/// </summary>
|
|||
|
|
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
|
|||
|
|
private static void DomainReset()
|
|||
|
|
{
|
|||
|
|
s_Initialized = false;
|
|||
|
|
s_Instance = null;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
}
|