735 lines
38 KiB
C#
735 lines
38 KiB
C#
|
/// ---------------------------------------------
|
|||
|
|
/// Ultimate Character Controller
|
|||
|
|
/// Copyright (c) Opsive. All Rights Reserved.
|
|||
|
|
/// https://www.opsive.com
|
|||
|
|
/// ---------------------------------------------
|
|||
|
|
|
|||
|
|
namespace Opsive.UltimateCharacterController.ThirdPersonController.Camera
|
|||
|
|
{
|
|||
|
|
using Opsive.Shared.Events;
|
|||
|
|
using Opsive.Shared.Game;
|
|||
|
|
using Opsive.Shared.Utility;
|
|||
|
|
using Opsive.UltimateCharacterController.Camera;
|
|||
|
|
using Opsive.UltimateCharacterController.Character;
|
|||
|
|
using Opsive.UltimateCharacterController.Character.Identifiers;
|
|||
|
|
using Opsive.UltimateCharacterController.Items;
|
|||
|
|
using Opsive.UltimateCharacterController.StateSystem;
|
|||
|
|
using Opsive.UltimateCharacterController.Utility;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using UnityEngine;
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Can fade the character's materials if the camera gets too close or any materials which are obstructing the view between the camera and the character.
|
|||
|
|
/// </summary>
|
|||
|
|
public class ObjectFader : StateBehavior
|
|||
|
|
{
|
|||
|
|
[Tooltip("The name of the material property that should be faded.")]
|
|||
|
|
[SerializeField] protected string m_ColorPropertyName = "_Color";
|
|||
|
|
[Tooltip("Should the character fade out when the camera is near?")]
|
|||
|
|
[SerializeField] protected bool m_CharacterFade = true;
|
|||
|
|
[Tooltip("Should the character materials be cached at the start? If false the material values will be saved each time the character starts to fade.")]
|
|||
|
|
[SerializeField] protected bool m_CacheCharacterMaterials = true;
|
|||
|
|
[Tooltip("The distance between the character and camera that the character materials should start to fade.")]
|
|||
|
|
[SerializeField] protected float m_StartFadeDistance = 1.8f;
|
|||
|
|
[Tooltip("The distance between the character and camera that the character materials should be completely invisible.")]
|
|||
|
|
[SerializeField] protected float m_EndFadeDistance = 1;
|
|||
|
|
[Tooltip("Prevents the character change from updating for the specified number of seconds after a state change.")]
|
|||
|
|
[SerializeField] protected float m_CharacterFadeStateChangeCooldown = 0.3f;
|
|||
|
|
[Tooltip("Should any objects obstructing the camera's view fade out?")]
|
|||
|
|
[SerializeField] protected bool m_ObstructingObjectsFade;
|
|||
|
|
[Tooltip("The radius of the camera's collision sphere to prevent it from clipping with other objects.")]
|
|||
|
|
[SerializeField] protected float m_CollisionRadius = 0.05f;
|
|||
|
|
[Tooltip("Specifies the speed at which the obstructing material can fade.")]
|
|||
|
|
[SerializeField] protected float m_FadeSpeed = 0.02f;
|
|||
|
|
[Tooltip("The color that the obstructed object will fade to.")]
|
|||
|
|
[SerializeField] protected Color m_FadeColor = new Color(1, 1, 1, 0);
|
|||
|
|
[Tooltip("Should the material mode be set automatically when an object is obstructing the view?")]
|
|||
|
|
[SerializeField] protected bool m_AutoSetMode;
|
|||
|
|
[Tooltip("Should the obstructing object's collider be disabled when the material is faded?")]
|
|||
|
|
[SerializeField] protected bool m_DisableCollider = true;
|
|||
|
|
[Tooltip("The maximum number of obstructing colliders that can be faded at one time.")]
|
|||
|
|
[SerializeField] protected int m_MaxObstructingColliderCount = 20;
|
|||
|
|
[Tooltip("The maximum number of obstricting materials that can be faded at one time. This value should be greater than the collider count.")]
|
|||
|
|
[SerializeField] protected int m_MaxObstructingMaterialCount = 30;
|
|||
|
|
[Tooltip("The offset to apply to the character when determining if the character should fade/is considered obstructed.")]
|
|||
|
|
[SerializeField] protected Vector3 m_TransformOffset = new Vector3(0, 0.9f, 0);
|
|||
|
|
|
|||
|
|
public bool CharacterFade { get { return m_CharacterFade; } set { m_CharacterFade = value; if (!value) { DisableCharacterFade(); } } }
|
|||
|
|
public float StartFadeDistance { get { return m_StartFadeDistance; } set { m_StartFadeDistance = value; } }
|
|||
|
|
public float EndFadeDistance { get { return m_EndFadeDistance; } set { m_EndFadeDistance = value; } }
|
|||
|
|
public float CharacterFadeStateChangeCooldown { get { return m_CharacterFadeStateChangeCooldown; } set { m_CharacterFadeStateChangeCooldown = value; } }
|
|||
|
|
public bool ObstructingObjectsFade { get { return m_ObstructingObjectsFade; } set { m_ObstructingObjectsFade = value; if (!value) { DisableObstructingFade(); } } }
|
|||
|
|
public float CollisionRadius { get { return m_CollisionRadius; } set { m_CollisionRadius = value; } }
|
|||
|
|
public float FadeSpeed { get { return m_FadeSpeed; } set { m_FadeSpeed = value; } }
|
|||
|
|
public Color FadeColor { get { return m_FadeColor; } set { m_FadeColor = value; } }
|
|||
|
|
public bool AutoSetMode { get { return m_AutoSetMode; } set { m_AutoSetMode = value; } }
|
|||
|
|
public bool DisableCollider { get { return m_DisableCollider; } set { m_DisableCollider = value; } }
|
|||
|
|
public Vector3 TransformOffset { get { return m_TransformOffset; } set { m_TransformOffset = value; } }
|
|||
|
|
|
|||
|
|
private Transform m_Transform;
|
|||
|
|
private CameraController m_CameraController;
|
|||
|
|
|
|||
|
|
private GameObject m_Character;
|
|||
|
|
private UltimateCharacterLocomotion m_CharacterLocomotion;
|
|||
|
|
private CharacterLayerManager m_CharacterLayerManager;
|
|||
|
|
private Transform m_CharacterTransform;
|
|||
|
|
private Material[] m_CharacterFadeMaterials;
|
|||
|
|
|
|||
|
|
private int m_IndependentCharacterFadeCount;
|
|||
|
|
private int m_CharacterFadeMaterialsCount;
|
|||
|
|
private HashSet<Material> m_RegisteredMaterial;
|
|||
|
|
private Vector3 m_FadeOffset;
|
|||
|
|
private bool m_CharacterFaded;
|
|||
|
|
private Dictionary<Material, OriginalMaterialValue> m_OriginalMaterialValuesMap = new Dictionary<Material, OriginalMaterialValue>();
|
|||
|
|
private RaycastHit[] m_RaycastsHit;
|
|||
|
|
private Material[] m_ObstructingMaterials;
|
|||
|
|
private int m_ObstructingMaterialsCount;
|
|||
|
|
private Collider[] m_ObstructingColliders;
|
|||
|
|
private int m_ObstructingCollidersCount;
|
|||
|
|
private HashSet<Material> m_ObstructionHitSet;
|
|||
|
|
private Dictionary<Material, bool> m_CanObstructionFade;
|
|||
|
|
private HashSet<Material> m_MaterialModeSet;
|
|||
|
|
private float m_CharacterFadeCooldownElapsedTime;
|
|||
|
|
|
|||
|
|
private int m_ColorID;
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Initialize the default values.
|
|||
|
|
/// </summary>
|
|||
|
|
protected override void Awake()
|
|||
|
|
{
|
|||
|
|
// PropertyToID cannot be initialized within a MonoBehaviour constructor.
|
|||
|
|
m_ColorID = Shader.PropertyToID(m_ColorPropertyName);
|
|||
|
|
|
|||
|
|
base.Awake();
|
|||
|
|
|
|||
|
|
m_Transform = transform;
|
|||
|
|
m_CameraController = gameObject.GetCachedComponent<CameraController>();
|
|||
|
|
if (m_CharacterFade) {
|
|||
|
|
m_RegisteredMaterial = new HashSet<Material>();
|
|||
|
|
m_MaterialModeSet = new HashSet<Material>();
|
|||
|
|
}
|
|||
|
|
if (m_ObstructingObjectsFade) {
|
|||
|
|
m_RaycastsHit = new RaycastHit[m_MaxObstructingColliderCount];
|
|||
|
|
m_ObstructingMaterials = new Material[m_MaxObstructingMaterialCount];
|
|||
|
|
m_ObstructingColliders = new Collider[m_MaxObstructingMaterialCount];
|
|||
|
|
m_ObstructionHitSet = new HashSet<Material>();
|
|||
|
|
m_CanObstructionFade = new Dictionary<Material, bool>();
|
|||
|
|
}
|
|||
|
|
m_CharacterFadeCooldownElapsedTime = -m_CharacterFadeStateChangeCooldown;
|
|||
|
|
|
|||
|
|
EventHandler.RegisterEvent<GameObject>(gameObject, "OnCameraAttachCharacter", OnAttachCharacter);
|
|||
|
|
|
|||
|
|
// Enable after the character has been attached.
|
|||
|
|
enabled = false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Attaches the component to the specified character.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="character">The handler to attach the camera to.</param>
|
|||
|
|
protected virtual void OnAttachCharacter(GameObject character)
|
|||
|
|
{
|
|||
|
|
enabled = character != null && !m_CameraController.ActiveViewType.FirstPersonPerspective;
|
|||
|
|
|
|||
|
|
// Disable the fade on the previous active character.
|
|||
|
|
if (m_CharacterFade) {
|
|||
|
|
if (m_Character != null && m_Character != character) {
|
|||
|
|
DisableFades();
|
|||
|
|
|
|||
|
|
// Clear the previous mappings.
|
|||
|
|
if (m_CharacterFadeMaterials != null) {
|
|||
|
|
if (m_CacheCharacterMaterials) {
|
|||
|
|
for (int i = 0; i < m_CharacterFadeMaterials.Length; ++i) {
|
|||
|
|
GenericObjectPool.Return(m_OriginalMaterialValuesMap[m_CharacterFadeMaterials[i]]);
|
|||
|
|
m_OriginalMaterialValuesMap.Remove(m_CharacterFadeMaterials[i]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
m_CharacterFadeMaterials = null;
|
|||
|
|
}
|
|||
|
|
m_OriginalMaterialValuesMap.Clear();
|
|||
|
|
|
|||
|
|
EventHandler.UnregisterEvent<bool>(m_Character, "OnCameraChangePerspectives", OnChangePerspectives);
|
|||
|
|
EventHandler.UnregisterEvent<bool, bool>(m_Character, "OnCharacterIndependentFade", OnIndependentFade);
|
|||
|
|
EventHandler.UnregisterEvent<Item>(m_Character, "OnInventoryAddItem", OnAddItem);
|
|||
|
|
EventHandler.UnregisterEvent<GameObject, bool>(m_Character, "OnShootableWeaponShowProjectile", OnShowProjectile);
|
|||
|
|
EventHandler.UnregisterEvent(m_Character, "OnRespawn", OnRespawn);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_Character = character;
|
|||
|
|
|
|||
|
|
if (m_Character != null) {
|
|||
|
|
m_CharacterTransform = m_Character.transform;
|
|||
|
|
m_CharacterLocomotion = m_Character.GetCachedComponent<UltimateCharacterLocomotion>();
|
|||
|
|
m_CharacterLayerManager = m_Character.GetCachedComponent<CharacterLayerManager>();
|
|||
|
|
if (m_CharacterFade) {
|
|||
|
|
// Determine the number of renderers that will be faded so their materials can be cached.
|
|||
|
|
m_RegisteredMaterial.Clear();
|
|||
|
|
var count = 0;
|
|||
|
|
var renderers = m_Character.GetComponentsInChildren<Renderer>(true);
|
|||
|
|
for (int i = 0; i < renderers.Length; ++i) {
|
|||
|
|
// The renderer fade can be ignored.
|
|||
|
|
if (renderers[i].gameObject.GetCachedComponent<IgnoreFadeIdentifier>() != null) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
var materials = renderers[i].materials;
|
|||
|
|
for (int j = 0; j < materials.Length; ++j) {
|
|||
|
|
if (materials[j].HasProperty(m_ColorID)) {
|
|||
|
|
count++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (count > 0) {
|
|||
|
|
if (m_CharacterFadeMaterials == null) {
|
|||
|
|
m_CharacterFadeMaterials = new Material[count];
|
|||
|
|
} else if (m_CharacterFadeMaterials.Length != count) {
|
|||
|
|
if (m_CacheCharacterMaterials) {
|
|||
|
|
// The mapping may exist from a previous character.
|
|||
|
|
for (int i = 0; i < m_CharacterFadeMaterials.Length; ++i) {
|
|||
|
|
GenericObjectPool.Return(m_OriginalMaterialValuesMap[m_CharacterFadeMaterials[i]]);
|
|||
|
|
m_OriginalMaterialValuesMap.Remove(m_CharacterFadeMaterials[i]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
System.Array.Resize(ref m_CharacterFadeMaterials, count);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Cache a reference to all of the faded materials.
|
|||
|
|
m_CharacterFadeMaterialsCount = 0;
|
|||
|
|
for (int i = 0; i < renderers.Length; ++i) {
|
|||
|
|
// The renderer fade can be ignored.
|
|||
|
|
if (renderers[i].gameObject.GetCachedComponent<IgnoreFadeIdentifier>() != null) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var materials = renderers[i].materials;
|
|||
|
|
for (int j = 0; j < materials.Length; ++j) {
|
|||
|
|
if (m_RegisteredMaterial.Contains(materials[j])) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
if (materials[j].HasProperty(m_ColorID)) {
|
|||
|
|
if (materials[j].HasProperty(OriginalMaterialValue.ModeID)) {
|
|||
|
|
m_MaterialModeSet.Add(materials[j]);
|
|||
|
|
}
|
|||
|
|
m_CharacterFadeMaterials[m_CharacterFadeMaterialsCount] = materials[j];
|
|||
|
|
m_RegisteredMaterial.Add(materials[j]);
|
|||
|
|
m_CharacterFadeMaterialsCount++;
|
|||
|
|
|
|||
|
|
if (m_CacheCharacterMaterials) {
|
|||
|
|
var originalMaterialValues = GenericObjectPool.Get<OriginalMaterialValue>();
|
|||
|
|
originalMaterialValues.Initialize(materials[j], m_ColorID, m_MaterialModeSet.Contains(materials[j]));
|
|||
|
|
m_OriginalMaterialValuesMap.Add(materials[j], originalMaterialValues);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
EventHandler.RegisterEvent<bool>(m_Character, "OnCameraChangePerspectives", OnChangePerspectives);
|
|||
|
|
EventHandler.RegisterEvent<Item>(m_Character, "OnInventoryAddItem", OnAddItem);
|
|||
|
|
EventHandler.RegisterEvent<GameObject, bool>(m_Character, "OnShootableWeaponShowProjectile", OnShowProjectile);
|
|||
|
|
EventHandler.RegisterEvent<bool, bool>(m_Character, "OnCharacterIndependentFade", OnIndependentFade);
|
|||
|
|
EventHandler.RegisterEvent(m_Character, "OnRespawn", OnRespawn);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Fade the obstructing objects immediately after the character has been assigned.
|
|||
|
|
if (m_ObstructingObjectsFade) {
|
|||
|
|
FadeObstructingObjects(true);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Update the fade values after the scene has finished positioning.
|
|||
|
|
/// </summary>
|
|||
|
|
private void Update()
|
|||
|
|
{
|
|||
|
|
FadeCharacter();
|
|||
|
|
|
|||
|
|
FadeObstructingObjects(false);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Fade the character to prevent the camera from seeing inside the character if the camera gets too close.
|
|||
|
|
/// </summary>
|
|||
|
|
private void FadeCharacter()
|
|||
|
|
{
|
|||
|
|
if (!m_CharacterFade || Time.time < m_CharacterFadeCooldownElapsedTime) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
m_FadeOffset = MathUtility.InverseTransformPoint(m_CharacterTransform.TransformPoint(m_TransformOffset), m_CharacterTransform.rotation, m_Transform.position);
|
|||
|
|
// Other components can control when the materials fade.
|
|||
|
|
if (m_IndependentCharacterFadeCount != 0) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (m_FadeOffset.magnitude <= m_StartFadeDistance) {
|
|||
|
|
EnableCharacterFade(m_FadeOffset.magnitude);
|
|||
|
|
} else if (m_CharacterFaded) {
|
|||
|
|
// The camera is not near the character - no fade necessary.
|
|||
|
|
DisableCharacterFade();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The MaterialSwapper component has started or stopped rendering.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="start">Did the MaterialSwapper component start to render?</param>
|
|||
|
|
public void MultiCameraRender(bool start)
|
|||
|
|
{
|
|||
|
|
if (!enabled) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (start && m_FadeOffset.magnitude <= m_StartFadeDistance) {
|
|||
|
|
EnableCharacterFade(m_FadeOffset.magnitude);
|
|||
|
|
} else if (!start) {
|
|||
|
|
DisableCharacterFade();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Starts to fade the character materials.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="distance">The distance from the character and camera.</param>
|
|||
|
|
private void EnableCharacterFade(float distance)
|
|||
|
|
{
|
|||
|
|
if (m_CharacterFadeMaterials != null) {
|
|||
|
|
// Slowly fade the character away as the camera gets closer.
|
|||
|
|
var amount = Mathf.Clamp01((distance - m_EndFadeDistance) / (m_StartFadeDistance - m_EndFadeDistance));
|
|||
|
|
for (int i = 0; i < m_CharacterFadeMaterialsCount; ++i) {
|
|||
|
|
if (!m_CharacterFaded) {
|
|||
|
|
EnableFadeMaterial(m_CharacterFadeMaterials[i]);
|
|||
|
|
}
|
|||
|
|
var color = m_CharacterFadeMaterials[i].GetColor(m_ColorID);
|
|||
|
|
color.a = Mathf.Lerp(0, 1, amount);
|
|||
|
|
m_CharacterFadeMaterials[i].SetColor(m_ColorID, color);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
m_CharacterFaded = true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Updates the shader to support a fade.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="material">The material to update.</param>
|
|||
|
|
private void EnableFadeMaterial(Material material)
|
|||
|
|
{
|
|||
|
|
// If the character's materials change at runtime then the values need to be saved every time fading is enabled.
|
|||
|
|
if (!m_CacheCharacterMaterials && !m_OriginalMaterialValuesMap.ContainsKey(material)) {
|
|||
|
|
var originalMaterialValues = GenericObjectPool.Get<OriginalMaterialValue>();
|
|||
|
|
originalMaterialValues.Initialize(material, m_ColorID, m_MaterialModeSet.Contains(material));
|
|||
|
|
m_OriginalMaterialValuesMap.Add(material, originalMaterialValues);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_MaterialModeSet.Contains(material)) {
|
|||
|
|
material.SetFloat(OriginalMaterialValue.ModeID, 2);
|
|||
|
|
material.SetInt(OriginalMaterialValue.SrcBlendID, (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
|
|||
|
|
material.SetInt(OriginalMaterialValue.DstBlendID, (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
|
|||
|
|
}
|
|||
|
|
material.EnableKeyword(OriginalMaterialValue.AlphaBlendString);
|
|||
|
|
material.renderQueue = 3000;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Reverts all of the character materials back to the original non-faded value.
|
|||
|
|
/// </summary>
|
|||
|
|
private void DisableCharacterFade()
|
|||
|
|
{
|
|||
|
|
if (m_CharacterFadeMaterials != null) {
|
|||
|
|
for (int i = 0; i < m_CharacterFadeMaterialsCount; ++i) {
|
|||
|
|
if (m_OriginalMaterialValuesMap.TryGetValue(m_CharacterFadeMaterials[i], out var materialValue)) {
|
|||
|
|
RevertMaterial(m_CharacterFadeMaterials[i], materialValue);
|
|||
|
|
if (!m_CacheCharacterMaterials) {
|
|||
|
|
m_OriginalMaterialValuesMap.Remove(m_CharacterFadeMaterials[i]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
m_CharacterFaded = false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Reverts the material back to the original non-faded value.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="material">The material to revert.</param>
|
|||
|
|
/// <param name="originalMaterialValue">A storage struct with the original values.</param>
|
|||
|
|
private void RevertMaterial(Material material, OriginalMaterialValue originalMaterialValue)
|
|||
|
|
{
|
|||
|
|
material.SetColor(m_ColorID, originalMaterialValue.Color);
|
|||
|
|
if (originalMaterialValue.ContainsMode) {
|
|||
|
|
material.SetFloat(OriginalMaterialValue.ModeID, originalMaterialValue.Mode);
|
|||
|
|
material.SetInt(OriginalMaterialValue.SrcBlendID, originalMaterialValue.SrcBlend);
|
|||
|
|
material.SetInt(OriginalMaterialValue.DstBlendID, originalMaterialValue.DstBlend);
|
|||
|
|
}
|
|||
|
|
if (!originalMaterialValue.AlphaBlend) {
|
|||
|
|
material.DisableKeyword(OriginalMaterialValue.AlphaBlendString);
|
|||
|
|
}
|
|||
|
|
material.renderQueue = originalMaterialValue.RenderQueue;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Fade any objects that get in the way between the character and the camera.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="immediateFade">Should the fade material be changed immediately?</param>
|
|||
|
|
private void FadeObstructingObjects(bool immediateFade)
|
|||
|
|
{
|
|||
|
|
if (!m_ObstructingObjectsFade) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Disable any obstructing colliders so the sphere cast can detect which objects are obstructing.
|
|||
|
|
for (int i = 0; i < m_ObstructingCollidersCount; ++i) {
|
|||
|
|
m_ObstructingColliders[i].enabled = true;
|
|||
|
|
}
|
|||
|
|
m_ObstructingCollidersCount = 0;
|
|||
|
|
|
|||
|
|
var characterPosition = m_CharacterTransform.TransformPoint(m_TransformOffset);
|
|||
|
|
var direction = (m_Transform.position - characterPosition);
|
|||
|
|
var start = characterPosition - direction.normalized * m_CollisionRadius;
|
|||
|
|
m_CharacterLocomotion.EnableColliderCollisionLayer(false);
|
|||
|
|
// Fire a sphere to prevent the camera from colliding with other objects.
|
|||
|
|
var hitCount = Physics.SphereCastNonAlloc(start, m_CollisionRadius, direction.normalized, m_RaycastsHit,
|
|||
|
|
direction.magnitude, m_CharacterLayerManager.IgnoreInvisibleCharacterWaterLayers, QueryTriggerInteraction.Ignore);
|
|||
|
|
m_CharacterLocomotion.EnableColliderCollisionLayer(true);
|
|||
|
|
|
|||
|
|
m_ObstructionHitSet.Clear();
|
|||
|
|
if (hitCount > 0) {
|
|||
|
|
// Loop through all of the hit colliders. For any collider that has been hit get all of the renderers. The materials that are used on the
|
|||
|
|
// renderers then need to be checked to determine if they can be faded. If the material can be faded place it in a set which will then
|
|||
|
|
// be checked in the next block to determine if the material should be faded.
|
|||
|
|
for (int i = 0; i < hitCount; ++i) {
|
|||
|
|
var renderers = m_RaycastsHit[i].transform.gameObject.GetCachedComponents<Renderer>();
|
|||
|
|
var obstructing = false;
|
|||
|
|
for (int j = 0; j < renderers.Length; ++j) {
|
|||
|
|
var materials = renderers[j].materials;
|
|||
|
|
for (int k = 0; k < materials.Length; ++k) {
|
|||
|
|
if (!m_CanObstructionFade.TryGetValue(materials[k], out var canFade)) {
|
|||
|
|
// Objects can fade if they have the color property and can be transparent.
|
|||
|
|
canFade = materials[k].HasProperty(m_ColorID) && (m_AutoSetMode || materials[k].renderQueue >= (int)UnityEngine.Rendering.RenderQueue.Transparent);
|
|||
|
|
m_CanObstructionFade.Add(materials[k], canFade);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (canFade) {
|
|||
|
|
var material = materials[k];
|
|||
|
|
// Any material contained within the hit set should be faded.
|
|||
|
|
m_ObstructionHitSet.Add(material);
|
|||
|
|
if (m_DisableCollider && !obstructing) {
|
|||
|
|
obstructing = CanMaterialFade(material);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// The same material may be applied to multiple renderers.
|
|||
|
|
if (!m_OriginalMaterialValuesMap.ContainsKey(material)) {
|
|||
|
|
// Don't set the mode automatically just because it has the property - not all objects in the environment should fade.
|
|||
|
|
if (m_AutoSetMode && material.HasProperty(OriginalMaterialValue.ModeID)) {
|
|||
|
|
m_MaterialModeSet.Add(material);
|
|||
|
|
}
|
|||
|
|
var originalMaterialValues = GenericObjectPool.Get<OriginalMaterialValue>();
|
|||
|
|
originalMaterialValues.Initialize(material, m_ColorID, m_MaterialModeSet.Contains(material));
|
|||
|
|
m_OriginalMaterialValuesMap.Add(material, originalMaterialValues);
|
|||
|
|
|
|||
|
|
m_ObstructingMaterials[m_ObstructingMaterialsCount] = material;
|
|||
|
|
m_ObstructingMaterialsCount++;
|
|||
|
|
|
|||
|
|
EnableFadeMaterial(material);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// If the object is faded then the collider has the option of being disabled to prevent it from causing collisions.
|
|||
|
|
if (m_DisableCollider && obstructing) {
|
|||
|
|
m_RaycastsHit[i].collider.enabled = false;
|
|||
|
|
m_ObstructingColliders[m_ObstructingCollidersCount] = m_RaycastsHit[i].collider;
|
|||
|
|
m_ObstructingCollidersCount++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Once the obstructing objects have been found they should be faded. Note that this can cause a lot of overdraw so the FadeObject method can be
|
|||
|
|
// overridden to provide a custom effect such as the one described on https://madewith.unity.com/stories/dissolving-the-world-part-1.
|
|||
|
|
for (int i = m_ObstructingMaterialsCount - 1; i >= 0; --i) {
|
|||
|
|
if (!FadeMaterial(m_ObstructingMaterials[i], m_ObstructionHitSet.Contains(m_ObstructingMaterials[i]), immediateFade)) {
|
|||
|
|
RemoveObstructingMaterial(i);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Can the obstructing material fade?
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="material">The material that may be able to fade.</param>
|
|||
|
|
/// <returns>True if the material can fade.</returns>
|
|||
|
|
public bool CanMaterialFade(Material material)
|
|||
|
|
{
|
|||
|
|
// The material can fade if:
|
|||
|
|
// - The fader can disable the obstructing material's collider AND
|
|||
|
|
// - The material has the Mode property AND
|
|||
|
|
// - The Mode property can be set to fade OR
|
|||
|
|
// - The Mode property is already set to fade.
|
|||
|
|
return m_DisableCollider && material.HasProperty(OriginalMaterialValue.ModeID) && (m_AutoSetMode || material.GetInt(OriginalMaterialValue.ModeID) == 2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Fades the specified material by the amount.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="material">The material to fade.</param>
|
|||
|
|
/// <param name="fade">Is the object faded?</param>
|
|||
|
|
/// <param name="immediateFade">Should the fade material be changed immediately?</param>
|
|||
|
|
/// <returns>True if the object should continue to be faded, false if it is no longer faded.</returns>
|
|||
|
|
protected virtual bool FadeMaterial(Material material, bool fade, bool immediateFade)
|
|||
|
|
{
|
|||
|
|
// Set the alpha value to 0 if the object should be faded, otherwise set it to 1. As soon as the alpha value reaches 1 it should no longer be faded so
|
|||
|
|
// the method can return false.
|
|||
|
|
var color = material.GetColor(m_ColorID);
|
|||
|
|
var targetColor = fade ? m_FadeColor : Color.white;
|
|||
|
|
if (immediateFade) {
|
|||
|
|
color = targetColor;
|
|||
|
|
} else {
|
|||
|
|
color.r = Mathf.MoveTowards(color.r, targetColor.r, m_FadeSpeed);
|
|||
|
|
color.g = Mathf.MoveTowards(color.g, targetColor.g, m_FadeSpeed);
|
|||
|
|
color.b = Mathf.MoveTowards(color.b, targetColor.b, m_FadeSpeed);
|
|||
|
|
color.a = Mathf.MoveTowards(color.a, targetColor.a, m_FadeSpeed);
|
|||
|
|
}
|
|||
|
|
material.SetColor(m_ColorID, color);
|
|||
|
|
|
|||
|
|
return color.a != 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Removes the obstructing material at the specified index from the ObstructingMaterials array.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="index">The index of the obstructing material to remove.</param>
|
|||
|
|
private void RemoveObstructingMaterial(int index)
|
|||
|
|
{
|
|||
|
|
var originalMaterialValue = m_OriginalMaterialValuesMap[m_ObstructingMaterials[index]];
|
|||
|
|
RevertMaterial(m_ObstructingMaterials[index], originalMaterialValue);
|
|||
|
|
GenericObjectPool.Return(originalMaterialValue);
|
|||
|
|
m_OriginalMaterialValuesMap.Remove(m_ObstructingMaterials[index]);
|
|||
|
|
|
|||
|
|
// The object is no longer faded. Move the array elements down one.
|
|||
|
|
for (int j = index; j < m_ObstructingMaterialsCount - 1; ++j) {
|
|||
|
|
m_ObstructingMaterials[j] = m_ObstructingMaterials[j + 1];
|
|||
|
|
}
|
|||
|
|
m_ObstructingMaterialsCount--;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Disables all of the faded obstructing materials.
|
|||
|
|
/// </summary>
|
|||
|
|
private void DisableObstructingFade()
|
|||
|
|
{
|
|||
|
|
for (int i = m_ObstructingMaterialsCount - 1; i >= 0; --i) {
|
|||
|
|
RemoveObstructingMaterial(i);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for (int i = 0; i < m_ObstructingCollidersCount; ++i) {
|
|||
|
|
if (m_ObstructingColliders[i] != null) {
|
|||
|
|
m_ObstructingColliders[i].enabled = true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
m_ObstructingCollidersCount = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The camera perspective between first and third person has changed.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="firstPersonPerspective">Is the camera in a first person perspective?</param>
|
|||
|
|
private void OnChangePerspectives(bool firstPersonPerspective)
|
|||
|
|
{
|
|||
|
|
// While in a first person view no objects should be faded.
|
|||
|
|
if (firstPersonPerspective) {
|
|||
|
|
// Disable the fading within the update loop to prevent it from being disabled too early.
|
|||
|
|
Scheduler.Schedule(Time.fixedDeltaTime, DisableFades);
|
|||
|
|
}
|
|||
|
|
enabled = !firstPersonPerspective;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Disables the character and obstruction fades.
|
|||
|
|
/// </summary>
|
|||
|
|
private void DisableFades()
|
|||
|
|
{
|
|||
|
|
DisableCharacterFade();
|
|||
|
|
DisableObstructingFade();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The inventory has added the specified item.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="item">The item that was added.</param>
|
|||
|
|
private void OnAddItem(Item item)
|
|||
|
|
{
|
|||
|
|
// All of the item's materials should be faded when it is added to the character.
|
|||
|
|
if (m_CharacterFade) {
|
|||
|
|
var perspectiveItem = item.GetComponent<Items.ThirdPersonPerspectiveItem>();
|
|||
|
|
if (perspectiveItem == null || perspectiveItem.Object == null) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
InitializeCharacterFadeRenderers(perspectiveItem.Object.GetComponentsInChildren<Renderer>(true));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Another object has started or stopped taking control of the character fade.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="enable">Is the component controlling the fade?</param>
|
|||
|
|
/// <param name="revertFade">Should the fade be reverted?</param>
|
|||
|
|
private void OnIndependentFade(bool enable, bool revertFade)
|
|||
|
|
{
|
|||
|
|
m_IndependentCharacterFadeCount += enable ? 1 : -1;
|
|||
|
|
if (enable && revertFade) {
|
|||
|
|
DisableCharacterFade();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Initializes the materials on the renderers for character fade.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="renderers">The renderers that should be initilaizes for character fade.</param>
|
|||
|
|
private void InitializeCharacterFadeRenderers(Renderer[] renderers)
|
|||
|
|
{
|
|||
|
|
var count = 0;
|
|||
|
|
for (int i = 0; i < renderers.Length; ++i) {
|
|||
|
|
// The renderer fade can be ignored.
|
|||
|
|
if (renderers[i].gameObject.GetCachedComponent<IgnoreFadeIdentifier>() != null) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
var materials = renderers[i].materials;
|
|||
|
|
for (int j = 0; j < materials.Length; ++j) {
|
|||
|
|
if (!m_RegisteredMaterial.Contains(materials[j]) && materials[j].HasProperty(m_ColorID)) {
|
|||
|
|
count++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (count > 0) {
|
|||
|
|
var totalCount = m_CharacterFadeMaterialsCount + count;
|
|||
|
|
if (totalCount >= m_CharacterFadeMaterials.Length) {
|
|||
|
|
System.Array.Resize(ref m_CharacterFadeMaterials, totalCount);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Cache a reference to all of the faded materials.
|
|||
|
|
for (int i = 0; i < renderers.Length; ++i) {
|
|||
|
|
// The renderer fade can be ignored.
|
|||
|
|
if (renderers[i].gameObject.GetCachedComponent<IgnoreFadeIdentifier>() != null) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
var materials = renderers[i].materials;
|
|||
|
|
for (int j = 0; j < materials.Length; ++j) {
|
|||
|
|
if (!m_RegisteredMaterial.Contains(materials[j]) && materials[j].HasProperty(m_ColorID)) {
|
|||
|
|
if (materials[j].HasProperty(OriginalMaterialValue.ModeID)) {
|
|||
|
|
m_MaterialModeSet.Add(materials[j]);
|
|||
|
|
}
|
|||
|
|
m_CharacterFadeMaterials[m_CharacterFadeMaterialsCount] = materials[j];
|
|||
|
|
m_RegisteredMaterial.Add(materials[j]);
|
|||
|
|
m_CharacterFadeMaterialsCount++;
|
|||
|
|
|
|||
|
|
if (m_CacheCharacterMaterials && !m_OriginalMaterialValuesMap.ContainsKey(materials[j])) {
|
|||
|
|
var originalMaterialValues = GenericObjectPool.Get<OriginalMaterialValue>();
|
|||
|
|
originalMaterialValues.Initialize(materials[j], m_ColorID, m_MaterialModeSet.Contains(materials[j]));
|
|||
|
|
m_OriginalMaterialValuesMap.Add(materials[j], originalMaterialValues);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The ShootableWeapon ItemAction has shown or hidden a projectile.
|
|||
|
|
/// </summary>
|
|||
|
|
/// <param name="projectile">The projectile shown or hidden.</param>
|
|||
|
|
/// <param name="show">Is the projectile being shown?</param>
|
|||
|
|
private void OnShowProjectile(GameObject projectile, bool show)
|
|||
|
|
{
|
|||
|
|
// The projectile may not have a renderer.
|
|||
|
|
var renderers = projectile.GetCachedComponents<Renderer>();
|
|||
|
|
if (renderers == null || renderers.Length == 0) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (show) {
|
|||
|
|
// Initalize all of the materials.
|
|||
|
|
InitializeCharacterFadeRenderers(renderers);
|
|||
|
|
} else {
|
|||
|
|
// Remove all of the materials from the fade.
|
|||
|
|
for (int i = renderers.Length - 1; i > -1; --i) {
|
|||
|
|
var materials = renderers[i].materials;
|
|||
|
|
for (int j = materials.Length - 1; j > -1; --j) {
|
|||
|
|
if (!m_RegisteredMaterial.Contains(materials[j])) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
// Remove the material from the array. The array won't resize when the material is removed so start from the end to
|
|||
|
|
// reduce the number of likely iterations.
|
|||
|
|
var index = -1;
|
|||
|
|
for (int k = m_CharacterFadeMaterialsCount - 1; k > -1; --k) {
|
|||
|
|
if (m_CharacterFadeMaterials[k] == materials[j]) {
|
|||
|
|
index = k;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
for (int k = index; k < m_CharacterFadeMaterialsCount - 1; ++k) {
|
|||
|
|
m_CharacterFadeMaterials[k] = m_CharacterFadeMaterials[k + 1];
|
|||
|
|
}
|
|||
|
|
m_CharacterFadeMaterialsCount--;
|
|||
|
|
m_CharacterFadeMaterials[m_CharacterFadeMaterialsCount] = null;
|
|||
|
|
m_RegisteredMaterial.Remove(materials[j]);
|
|||
|
|
|
|||
|
|
if (m_OriginalMaterialValuesMap.TryGetValue(materials[j], out var materialValue)) {
|
|||
|
|
RevertMaterial(materials[j], materialValue);
|
|||
|
|
if (!m_CacheCharacterMaterials) {
|
|||
|
|
m_OriginalMaterialValuesMap.Remove(materials[j]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The character has respawned.
|
|||
|
|
/// </summary>
|
|||
|
|
private void OnRespawn()
|
|||
|
|
{
|
|||
|
|
// The character should no longer be faded.
|
|||
|
|
DisableFades();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// Callback when the StateManager has changed the active state on the current object.
|
|||
|
|
/// </summary>
|
|||
|
|
public override void StateChange()
|
|||
|
|
{
|
|||
|
|
if (m_CharacterFade && m_RegisteredMaterial == null) {
|
|||
|
|
m_RegisteredMaterial = new HashSet<Material>();
|
|||
|
|
m_MaterialModeSet = new HashSet<Material>();
|
|||
|
|
} else if (!m_CharacterFade) {
|
|||
|
|
DisableCharacterFade();
|
|||
|
|
}
|
|||
|
|
// In some cases the character fade should not update immediately - such as while zooming in third person to going back to a non-zoom state. This will prevent
|
|||
|
|
// the character from fading when the camera is moving back to the non-zoomed state.
|
|||
|
|
if (m_CharacterFadeStateChangeCooldown > 0) {
|
|||
|
|
m_CharacterFadeCooldownElapsedTime = Time.time + m_CharacterFadeStateChangeCooldown;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m_ObstructingObjectsFade && m_ObstructingMaterials == null) {
|
|||
|
|
m_RaycastsHit = new RaycastHit[m_MaxObstructingColliderCount];
|
|||
|
|
m_ObstructingMaterials = new Material[m_MaxObstructingMaterialCount];
|
|||
|
|
m_ObstructingColliders = new Collider[m_MaxObstructingMaterialCount];
|
|||
|
|
m_ObstructionHitSet = new HashSet<Material>();
|
|||
|
|
m_CanObstructionFade = new Dictionary<Material, bool>();
|
|||
|
|
} else if (!m_ObstructingObjectsFade) {
|
|||
|
|
DisableObstructingFade();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>
|
|||
|
|
/// The camera has been destroyed.
|
|||
|
|
/// </summary>
|
|||
|
|
private void OnDestroy()
|
|||
|
|
{
|
|||
|
|
EventHandler.UnregisterEvent<GameObject>(gameObject, "OnCameraAttachCharacter", OnAttachCharacter);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|