update
This commit is contained in:
@@ -1,667 +0,0 @@
|
||||
/// ---------------------------------------------
|
||||
/// Ultimate Character Controller
|
||||
/// Copyright (c) Opsive. All Rights Reserved.
|
||||
/// https://www.opsive.com
|
||||
/// ---------------------------------------------
|
||||
|
||||
namespace Opsive.UltimateCharacterController.Utility
|
||||
{
|
||||
using Opsive.Shared.Game;
|
||||
using Opsive.UltimateCharacterController.Camera;
|
||||
using System;
|
||||
using System.Reflection;
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
|
||||
/// <summary>
|
||||
/// Contains a set of utility functions useful for interacting with the Unity Engine.
|
||||
/// </summary>
|
||||
public class UnityEngineUtility
|
||||
{
|
||||
private static Dictionary<string, Type> s_TypeLookup = new Dictionary<string, Type>();
|
||||
private static List<Assembly> s_LoadedAssemblies = null;
|
||||
private static Dictionary<GameObject, UnityEngine.Camera> s_GameObjectCameraMap = new Dictionary<GameObject, UnityEngine.Camera>();
|
||||
public static HashSet<object> s_ObjectUpdated = new HashSet<object>();
|
||||
public static ScheduledEventBase s_ObjectClearEvent;
|
||||
private static Dictionary<FieldInfo, Dictionary<Type, bool>> s_FieldAttributeMap;
|
||||
private static Dictionary<PropertyInfo, Dictionary<Type, bool>> s_PropertyAttributeMap;
|
||||
|
||||
/// <summary>
|
||||
/// Searches through all of the loaded assembies for the specified type.
|
||||
/// </summary>
|
||||
/// <param name="name">The string value of the type.</param>
|
||||
/// <returns>The found Type. Can be null.</returns>
|
||||
public static Type GetType(string name)
|
||||
{
|
||||
if (string.IsNullOrEmpty(name)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
Type type;
|
||||
// Cache the results for quick repeated lookup.
|
||||
if (s_TypeLookup.TryGetValue(name, out type)) {
|
||||
return type;
|
||||
}
|
||||
|
||||
type = Type.GetType(name);
|
||||
// Look in the loaded assemblies.
|
||||
if (type == null) {
|
||||
if (s_LoadedAssemblies == null || s_LoadedAssemblies.Count == 0) {
|
||||
#if NETFX_CORE && !UNITY_EDITOR
|
||||
s_LoadedAssemblies = GetStorageFileAssemblies(typeName).Result;
|
||||
#else
|
||||
s_LoadedAssemblies = new List<Assembly>();
|
||||
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
|
||||
for (int i = 0; i < assemblies.Length; ++i) {
|
||||
s_LoadedAssemblies.Add(assemblies[i]);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
// Continue until the type is found.
|
||||
for (int i = 0; i < s_LoadedAssemblies.Count; ++i) {
|
||||
type = s_LoadedAssemblies[i].GetType(name);
|
||||
if (type != null) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (type == null) {
|
||||
// TODO: QuickStart and QuickStop were renamed in version 2.1.3.
|
||||
if (name == "Opsive.UltimateCharacterController.Character.Abilities.StartMovement") {
|
||||
return GetType("Opsive.UltimateCharacterController.Character.Abilities.QuickStart");
|
||||
}
|
||||
if (name == "Opsive.UltimateCharacterController.Character.Abilities.StopMovement") {
|
||||
return GetType("Opsive.UltimateCharacterController.Character.Abilities.QuickStop");
|
||||
}
|
||||
// TODO: Add-on directory was renamed in 2.1.5.
|
||||
if (name.Contains("Opsive.UltimateCharacterController.Addons.")) {
|
||||
return GetType(name.Replace("Opsive.UltimateCharacterController.Addons.", "Opsive.UltimateCharacterController.AddOns."));
|
||||
}
|
||||
}
|
||||
if (type != null) {
|
||||
s_TypeLookup.Add(name, type);
|
||||
}
|
||||
return type;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns a friendly name for the specified type.
|
||||
/// </summary>
|
||||
/// <param name="type">The type to retieve the name of.</param>
|
||||
/// <returns>A friendly name for the specified type.</returns>
|
||||
public static string GetFriendlyName(Type type)
|
||||
{
|
||||
return GetFriendlyName(type.FullName, type.Name);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns a friendly name for the specified type.
|
||||
/// </summary>
|
||||
/// <param name="fullName">The full name of the type.</param>
|
||||
/// <param name="name">The name of the type.</param>
|
||||
/// <returns>A friendly name for the specified type.</returns>
|
||||
public static string GetFriendlyName(string fullName, string name)
|
||||
{
|
||||
if (fullName.Contains("FirstPersonController")) {
|
||||
return "First Person " + name;
|
||||
} else if (fullName.Contains("ThirdPersonController")) {
|
||||
return "Third Person " + name;
|
||||
}
|
||||
return name;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns true if the field has the specified attribute.
|
||||
/// </summary>
|
||||
/// <param name="field">The field to determine if it has the attribute.</param>
|
||||
/// <param name="attribute">The attribute to compare against.</param>
|
||||
/// <returns>Tue if the field has the specified attribute.</returns>
|
||||
public static bool HasAttribute(FieldInfo field, Type attribute)
|
||||
{
|
||||
if (field == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Cache the results for quick repeated lookup.
|
||||
if (s_FieldAttributeMap == null) {
|
||||
s_FieldAttributeMap = new Dictionary<FieldInfo, Dictionary<Type, bool>>();
|
||||
}
|
||||
|
||||
Dictionary<Type, bool> typeLookup;
|
||||
if (!s_FieldAttributeMap.TryGetValue(field, out typeLookup)) {
|
||||
typeLookup = new Dictionary<Type, bool>();
|
||||
s_FieldAttributeMap.Add(field, typeLookup);
|
||||
}
|
||||
|
||||
// The static field attribute map contains a dictionary of attributes that the specified type has. Add to that dictionary if the current
|
||||
// attribute type hasn't been retrieved before.
|
||||
var hasAttribute = false;
|
||||
if (!typeLookup.TryGetValue(attribute, out hasAttribute)) {
|
||||
hasAttribute = field.GetCustomAttributes(attribute, false).Length > 0;
|
||||
typeLookup.Add(attribute, hasAttribute);
|
||||
}
|
||||
|
||||
return hasAttribute;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns true if the property has the specified attribute.
|
||||
/// </summary>
|
||||
/// <param name="property">The property to determine if it has the attribute.</param>
|
||||
/// <param name="attribute">The attribute to compare against.</param>
|
||||
/// <returns>Tue if the property has the specified attribute.</returns>
|
||||
public static bool HasAttribute(PropertyInfo property, Type attribute)
|
||||
{
|
||||
if (property == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Cache the results for quick repeated lookup.
|
||||
if (s_PropertyAttributeMap == null) {
|
||||
s_PropertyAttributeMap = new Dictionary<PropertyInfo, Dictionary<Type, bool>>();
|
||||
}
|
||||
|
||||
Dictionary<Type, bool> typeLookup;
|
||||
if (!s_PropertyAttributeMap.TryGetValue(property, out typeLookup)) {
|
||||
typeLookup = new Dictionary<Type, bool>();
|
||||
s_PropertyAttributeMap.Add(property, typeLookup);
|
||||
}
|
||||
|
||||
// The static property attribute map contains a dictionary of attributes that the specified type has. Add to that dictionary if the current
|
||||
// attribute type hasn't been retrieved before.
|
||||
var hasAttribute = false;
|
||||
if (!typeLookup.TryGetValue(attribute, out hasAttribute)) {
|
||||
hasAttribute = property.GetCustomAttributes(attribute, false).Length > 0;
|
||||
typeLookup.Add(attribute, hasAttribute);
|
||||
}
|
||||
|
||||
return hasAttribute;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns the camera with the MainCamera tag or the camera with the CameraController attached.
|
||||
/// </summary>
|
||||
/// <param name="character">The character that the camera is attached to.</param>
|
||||
/// <returns>The found camera (if any).</returns>
|
||||
public static UnityEngine.Camera FindCamera(GameObject character)
|
||||
{
|
||||
UnityEngine.Camera camera;
|
||||
if (character != null) {
|
||||
if (s_GameObjectCameraMap.TryGetValue(character, out camera)) {
|
||||
// The reference may be null if the scene changed.
|
||||
if (camera != null) {
|
||||
return camera;
|
||||
}
|
||||
// The reference is null - search for the camera again.
|
||||
s_GameObjectCameraMap.Remove(character);
|
||||
}
|
||||
}
|
||||
// First try to find the camera with the character attached. If no camera has the character attached the return the first camera with the CameraController.
|
||||
camera = SearchForCamera(character);
|
||||
if (camera == null) {
|
||||
camera = SearchForCamera(null);
|
||||
if (camera != null) {
|
||||
// The camera controller's character field must be null or equal to the existing character.
|
||||
var cameraController = camera.GetComponent<CameraController>();
|
||||
if (cameraController.Character != null && cameraController.Character != character) {
|
||||
camera = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (camera != null && character != null) {
|
||||
s_GameObjectCameraMap.Add(character, camera);
|
||||
}
|
||||
return camera;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Loops through the cameras searching for a camera with the character assigned.
|
||||
/// </summary>
|
||||
/// <param name="character">The character to search for. Can be null.</param>
|
||||
/// <returns>The camera with the character assigned.</returns>
|
||||
private static UnityEngine.Camera SearchForCamera(GameObject character)
|
||||
{
|
||||
CameraController cameraController;
|
||||
UnityEngine.Camera mainCamera;
|
||||
if ((mainCamera = UnityEngine.Camera.main) != null && (cameraController = mainCamera.GetComponent<CameraController>()) != null && (character == null || cameraController.Character == character)) {
|
||||
return mainCamera;
|
||||
}
|
||||
var cameraControllers = UnityEngine.Object.FindObjectsOfType<CameraController>();
|
||||
for (int i = 0; i < cameraControllers.Length; ++i) {
|
||||
if (character == null || cameraControllers[i].Character == character) {
|
||||
return cameraControllers[i].GetComponent<UnityEngine.Camera>();
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns true if the specified object has been updated.
|
||||
/// </summary>
|
||||
/// <param name="obj">The object to check if it has been updated.</param>
|
||||
/// <returns>True if the specified object has been updated.</returns>
|
||||
public static bool HasUpdatedObject(object obj)
|
||||
{
|
||||
return s_ObjectUpdated.Contains(obj);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds the specified object to the set.
|
||||
/// </summary>
|
||||
/// <param name="obj">The object that has been updated.</param>
|
||||
public static void AddUpdatedObject(object obj)
|
||||
{
|
||||
AddUpdatedObject(obj, false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds the specified object to the set.
|
||||
/// </summary>
|
||||
/// <param name="obj">The object that has been updated.</param>
|
||||
/// <param name="autoClear">Should the object updated map be automatically cleared on the next tick?</param>
|
||||
public static void AddUpdatedObject(object obj, bool autoClear)
|
||||
{
|
||||
s_ObjectUpdated.Add(obj);
|
||||
|
||||
if (autoClear && s_ObjectClearEvent == null) {
|
||||
s_ObjectClearEvent = Scheduler.Schedule(0.0001f, ClearUpdatedObjectsEvent);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Removes all of the objects from the set.
|
||||
/// </summary>
|
||||
public static void ClearUpdatedObjects()
|
||||
{
|
||||
s_ObjectUpdated.Clear();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Removes all of the objects from the set and sets the event to null.
|
||||
/// </summary>
|
||||
private static void ClearUpdatedObjectsEvent()
|
||||
{
|
||||
ClearUpdatedObjects();
|
||||
s_ObjectClearEvent = null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Change the size of the RectTransform according to the size of the sprite.
|
||||
/// </summary>
|
||||
/// <param name="sprite">The sprite that the RectTransform should change its size to.</param>
|
||||
/// <param name="spriteRectTransform">A reference to the sprite's RectTransform.</param>
|
||||
public static void SizeSprite(Sprite sprite, RectTransform spriteRectTransform)
|
||||
{
|
||||
if (sprite != null) {
|
||||
var sizeDelta = spriteRectTransform.sizeDelta;
|
||||
sizeDelta.x = sprite.textureRect.width;
|
||||
sizeDelta.y = sprite.textureRect.height;
|
||||
spriteRectTransform.sizeDelta = sizeDelta;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Clears the Unity Engine Utility cache.
|
||||
/// </summary>
|
||||
///
|
||||
#if UNITY_2019_3_OR_NEWER
|
||||
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
|
||||
#endif
|
||||
public static void ClearCache()
|
||||
{
|
||||
if (s_TypeLookup != null) { s_TypeLookup.Clear(); }
|
||||
if (s_GameObjectCameraMap != null) { s_GameObjectCameraMap.Clear(); }
|
||||
if (s_ObjectUpdated != null) { s_ObjectUpdated.Clear(); }
|
||||
if (s_LoadedAssemblies != null) { s_LoadedAssemblies.Clear(); }
|
||||
if (s_FieldAttributeMap != null) { s_FieldAttributeMap.Clear(); }
|
||||
if (s_PropertyAttributeMap != null) { s_PropertyAttributeMap.Clear(); }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Allows for comparison between RaycastHit objects.
|
||||
/// </summary>
|
||||
public class RaycastHitComparer : IComparer<RaycastHit>
|
||||
{
|
||||
/// <summary>
|
||||
/// Compare RaycastHit x to RaycastHit y. If x has a smaller distance value compared to y then a negative value will be returned.
|
||||
/// If the distance values are equal then 0 will be returned, and if y has a smaller distance value compared to x then a positive value will be returned.
|
||||
/// </summary>
|
||||
/// <param name="x">The first RaycastHit to compare.</param>
|
||||
/// <param name="y">The second RaycastHit to compare.</param>
|
||||
/// <returns>The resulting difference between RaycastHit x and y.</returns>
|
||||
public int Compare(RaycastHit x, RaycastHit y)
|
||||
{
|
||||
if (x.transform == null) {
|
||||
return int.MaxValue;
|
||||
}
|
||||
if (y.transform == null) {
|
||||
return int.MinValue;
|
||||
}
|
||||
return x.distance.CompareTo(y.distance);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Allows for equity comparison checks between RaycastHit objects.
|
||||
/// </summary>
|
||||
public struct RaycastHitEqualityComparer : IEqualityComparer<RaycastHit>
|
||||
{
|
||||
/// <summary>
|
||||
/// Determines if RaycastHit x is equal to RaycastHit y.
|
||||
/// </summary>
|
||||
/// <param name="x">The first RaycastHit to compare.</param>
|
||||
/// <param name="y">The second RaycastHit to compare.</param>
|
||||
/// <returns>True if the raycasts are equal.</returns>
|
||||
public bool Equals(RaycastHit x, RaycastHit y)
|
||||
{
|
||||
if (x.distance != y.distance) {
|
||||
return false;
|
||||
}
|
||||
if (x.point != y.point) {
|
||||
return false;
|
||||
}
|
||||
if (x.normal != y.normal) {
|
||||
return false;
|
||||
}
|
||||
if (x.transform != y.transform) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns a hash code for the RaycastHit.
|
||||
/// </summary>
|
||||
/// <param name="hit">The RaycastHit to get the hash code of.</param>
|
||||
/// <returns>The hash code for the RaycastHit.</returns>
|
||||
public int GetHashCode(RaycastHit hit)
|
||||
{
|
||||
// Don't use hit.GetHashCode because that has boxing. This hash function won't always prevent duplicates but it's fine for what it's used for.
|
||||
return ((int)(hit.distance * 10000)) ^ ((int)(hit.point.x * 10000)) ^ ((int)(hit.point.y * 10000)) ^ ((int)(hit.point.z * 10000)) ^
|
||||
((int)(hit.normal.x * 10000)) ^ ((int)(hit.normal.y * 10000)) ^ ((int)(hit.normal.z * 10000));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A container for a min and max float value.
|
||||
/// </summary>
|
||||
[Serializable]
|
||||
public struct MinMaxFloat
|
||||
{
|
||||
[Tooltip("The minimum Vector3 value.")]
|
||||
[SerializeField] private float m_MinValue;
|
||||
[Tooltip("The maximum Vector3 value.")]
|
||||
[SerializeField] private float m_MaxValue;
|
||||
|
||||
public float MinValue { get { return m_MinValue; } set { m_MinValue = value; } }
|
||||
public float MaxValue { get { return m_MaxValue; } set { m_MaxValue = value; } }
|
||||
|
||||
public float RandomValue
|
||||
{
|
||||
get
|
||||
{
|
||||
return UnityEngine.Random.Range(m_MinValue, m_MaxValue);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// MinMaxFloat constructor which can specify the min and max values.
|
||||
/// </summary>
|
||||
/// <param name="minValue">The minimum float value.</param>
|
||||
/// <param name="maxValue">The maximum float value.</param>
|
||||
public MinMaxFloat(float minValue, float maxValue)
|
||||
{
|
||||
m_MinValue = minValue;
|
||||
m_MaxValue = maxValue;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// A container for a min and max Vector3 value.
|
||||
/// </summary>
|
||||
[Serializable]
|
||||
public struct MinMaxVector3
|
||||
{
|
||||
[Tooltip("The minimum Vector3 value.")]
|
||||
[SerializeField] private Vector3 m_MinValue;
|
||||
[Tooltip("The maximum Vector3 value.")]
|
||||
[SerializeField] private Vector3 m_MaxValue;
|
||||
[Tooltip("The minimum magnitude value when determining a random value.")]
|
||||
[SerializeField] private Vector3 m_MinMagnitude;
|
||||
|
||||
public Vector3 MinValue { get { return m_MinValue; } set { m_MinValue = value; } }
|
||||
public Vector3 MaxValue { get { return m_MaxValue; } set { m_MaxValue = value; } }
|
||||
public Vector3 MinMagnitude { get { return m_MinMagnitude; } set { m_MinMagnitude = value; } }
|
||||
|
||||
public Vector3 RandomValue
|
||||
{
|
||||
get
|
||||
{
|
||||
var value = Vector3.zero;
|
||||
value.x = GetRandomFloat(m_MinValue.x, m_MaxValue.x, m_MinMagnitude.x);
|
||||
value.y = GetRandomFloat(m_MinValue.y, m_MaxValue.y, m_MinMagnitude.y);
|
||||
value.z = GetRandomFloat(m_MinValue.z, m_MaxValue.z, m_MinMagnitude.z);
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// MinMaxVector3 constructor which can specify the min and max values.
|
||||
/// </summary>
|
||||
/// <param name="minValue">The minimum Vector3 value.</param>
|
||||
/// <param name="maxValue">The maximum Vector3 value.</param>
|
||||
public MinMaxVector3(Vector3 minValue, Vector3 maxValue)
|
||||
{
|
||||
m_MinValue = minValue;
|
||||
m_MaxValue = maxValue;
|
||||
m_MinMagnitude = Vector3.zero;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// MinMaxVector3 constructor which can specify the min and max values.
|
||||
/// </summary>
|
||||
/// <param name="minValue">The minimum Vector3 value.</param>
|
||||
/// <param name="maxValue">The maximum Vector3 value.</param>
|
||||
/// <param name="minMagnitude">The minimum magnitude of the random value.</param>
|
||||
public MinMaxVector3(Vector3 minValue, Vector3 maxValue, Vector3 minMagnitude)
|
||||
{
|
||||
m_MinValue = minValue;
|
||||
m_MaxValue = maxValue;
|
||||
m_MinMagnitude = minMagnitude;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns a random float between the min and max value with the specified minimum magnitude.
|
||||
/// </summary>
|
||||
/// <param name="minValue">The minimum float value.</param>
|
||||
/// <param name="maxValue">The maximum float value.</param>
|
||||
/// <param name="minMagnitude">The minimum magnitude of the random value.</param>
|
||||
/// <returns>A random float between the min and max value.</returns>
|
||||
private float GetRandomFloat(float minValue, float maxValue, float minMagnitude)
|
||||
{
|
||||
if (minMagnitude != 0 && Mathf.Sign(m_MinValue.x) != Mathf.Sign(m_MaxValue.x)) {
|
||||
if (Mathf.Sign(UnityEngine.Random.Range(m_MinValue.x, m_MaxValue.x)) > 0) {
|
||||
return UnityEngine.Random.Range(minMagnitude, Mathf.Max(minMagnitude, maxValue));
|
||||
}
|
||||
return UnityEngine.Random.Range(-minMagnitude, Mathf.Min(-minMagnitude, minValue));
|
||||
} else {
|
||||
return UnityEngine.Random.Range(minValue, maxValue);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Represents the object which can be spawned.
|
||||
/// </summary>
|
||||
[System.Serializable]
|
||||
public class ObjectSpawnInfo
|
||||
{
|
||||
#pragma warning disable 0649
|
||||
[Tooltip("The object that can be spawned.")]
|
||||
[SerializeField] private GameObject m_Object;
|
||||
[Tooltip("The probability that the object can be spawned.")]
|
||||
[Range(0, 1)] [SerializeField] private float m_Probability = 1;
|
||||
[Tooltip("Should a random spin be applied to the object after it has been spawned?")]
|
||||
[SerializeField] private bool m_RandomSpin;
|
||||
#pragma warning restore 0649
|
||||
|
||||
public GameObject Object { get { return m_Object; } }
|
||||
public float Probability { get { return m_Probability; } }
|
||||
public bool RandomSpin { get { return m_RandomSpin; } }
|
||||
|
||||
/// <summary>
|
||||
/// Instantiate the object.
|
||||
/// </summary>
|
||||
/// <param name="position">The position to instantiate the object at.</param>
|
||||
/// <param name="normal">The normal of the instantiated object.</param>
|
||||
/// <param name="gravityDirection">The normalized direction of the character's gravity.</param>
|
||||
/// <returns>The instantiated object (can be null). </returns>
|
||||
public GameObject Instantiate(Vector3 position, Vector3 normal, Vector3 gravityDirection)
|
||||
{
|
||||
if (m_Object == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
// There is a random chance that the object cannot be spawned.
|
||||
if (UnityEngine.Random.value < m_Probability) {
|
||||
var rotation = Quaternion.LookRotation(normal);
|
||||
// A random spin can be applied so the rotation isn't the same every hit.
|
||||
if (m_RandomSpin) {
|
||||
rotation *= Quaternion.AngleAxis(UnityEngine.Random.Range(0, 360), normal);
|
||||
}
|
||||
var instantiatedObject = ObjectPool.Instantiate(m_Object, position, rotation);
|
||||
// If the DirectionalConstantForce component exists then the gravity direction should be set so the object will move in the correct direction.
|
||||
var directionalConstantForce = instantiatedObject.GetCachedComponent<Traits.DirectionalConstantForce>();
|
||||
if (directionalConstantForce != null) {
|
||||
directionalConstantForce.Direction = gravityDirection;
|
||||
}
|
||||
return instantiatedObject;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Struct which stores the material values to revert back to after the material has been faded.
|
||||
/// </summary>
|
||||
public struct OriginalMaterialValue
|
||||
{
|
||||
[Tooltip("The color of the material.")]
|
||||
private Color m_Color;
|
||||
[Tooltip("Does the material have a mode property?")]
|
||||
private bool m_ContainsMode;
|
||||
[Tooltip("The render mode of the material.")]
|
||||
private float m_Mode;
|
||||
[Tooltip("The SourceBlend BlendMode of the material.")]
|
||||
private int m_SrcBlend;
|
||||
[Tooltip("The DestinationBlend BlendMode of the material.")]
|
||||
private int m_DstBlend;
|
||||
[Tooltip("Is alpha blend enabled?")]
|
||||
private bool m_AlphaBlend;
|
||||
[Tooltip("The render queue of the material.")]
|
||||
private int m_RenderQueue;
|
||||
|
||||
public Color Color { get { return m_Color; } set { m_Color = value; } }
|
||||
public bool ContainsMode { get { return m_ContainsMode; } set { m_ContainsMode = value; } }
|
||||
public float Mode { get { return m_Mode; } set { m_Mode = value; } }
|
||||
public int SrcBlend { get { return m_SrcBlend; } set { m_SrcBlend = value; } }
|
||||
public int DstBlend { get { return m_DstBlend; } set { m_DstBlend = value; } }
|
||||
public bool AlphaBlend { get { return m_AlphaBlend; } set { m_AlphaBlend = value; } }
|
||||
public int RenderQueue { get { return m_RenderQueue; } set { m_RenderQueue = value; } }
|
||||
|
||||
private static int s_ModeID;
|
||||
private static int s_SrcBlendID;
|
||||
private static int s_DstBlendID;
|
||||
private static string s_AlphaBlendString = "_ALPHABLEND_ON";
|
||||
|
||||
public static int ModeID { get { return s_ModeID; } }
|
||||
public static int SrcBlendID { get { return s_SrcBlendID; } }
|
||||
public static int DstBlendID { get { return s_DstBlendID; } }
|
||||
public static string AlphaBlendString { get { return s_AlphaBlendString; } }
|
||||
|
||||
/// <summary>
|
||||
/// Initializes the OriginalMaterialValue.
|
||||
/// </summary>
|
||||
[RuntimeInitializeOnLoadMethod]
|
||||
private static void Initialize()
|
||||
{
|
||||
s_ModeID = Shader.PropertyToID("_Mode");
|
||||
s_SrcBlendID = Shader.PropertyToID("_SrcBlend");
|
||||
s_DstBlendID = Shader.PropertyToID("_DstBlend");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes the OriginalMaterialValue to the material values.
|
||||
/// </summary>
|
||||
/// <param name="color">The material to initialize.</param>
|
||||
/// <param name="colorID">The id of the color property.</param>
|
||||
/// <param name="mode">Does the material have a Mode property?</param>
|
||||
public void Initialize(Material material, int colorID, bool containsMode)
|
||||
{
|
||||
m_Color = material.GetColor(colorID);
|
||||
m_AlphaBlend = material.IsKeywordEnabled(s_AlphaBlendString);
|
||||
m_RenderQueue = material.renderQueue;
|
||||
m_ContainsMode = containsMode;
|
||||
if (containsMode) {
|
||||
m_Mode = material.GetFloat(s_ModeID);
|
||||
m_SrcBlend = material.GetInt(s_SrcBlendID);
|
||||
m_DstBlend = material.GetInt(s_DstBlendID);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Storage class for determining if an event is triggered based on an animation event or time.
|
||||
/// </summary>
|
||||
[System.Serializable]
|
||||
public class AnimationEventTrigger
|
||||
{
|
||||
[Tooltip("Is the event triggered with a Unity animation event?")]
|
||||
[SerializeField] private bool m_WaitForAnimationEvent;
|
||||
[Tooltip("The amount of time it takes to trigger the event if not using an animation event.")]
|
||||
[SerializeField] private float m_Duration;
|
||||
|
||||
public bool WaitForAnimationEvent { get { return m_WaitForAnimationEvent; } set { m_WaitForAnimationEvent = value; } }
|
||||
public float Duration { get { return m_Duration; } set { m_Duration = value; } }
|
||||
|
||||
/// <summary>
|
||||
/// Default constructor.
|
||||
/// </summary>
|
||||
public AnimationEventTrigger() { }
|
||||
|
||||
/// <summary>
|
||||
/// Two parameter constructor for AnimationEventTrigger.
|
||||
/// </summary>
|
||||
/// <param name="waitForAnimationEvent">Is the event triggered with a Unity animation event?</param>
|
||||
/// <param name="duration">The amount of time it takes to trigger the event if not using an animation event.</param>
|
||||
public AnimationEventTrigger(bool waitForAnimationEvent, float duration)
|
||||
{
|
||||
m_WaitForAnimationEvent = waitForAnimationEvent;
|
||||
m_Duration = duration;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Attribute which allows the inspector to draw a foldout without the need of a custom editor.
|
||||
/// </summary>
|
||||
[AttributeUsage(AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
|
||||
public class InspectorFoldout : Attribute
|
||||
{
|
||||
private string m_Title;
|
||||
public string Title { get { return m_Title; } }
|
||||
public InspectorFoldout(string title)
|
||||
{
|
||||
m_Title = title;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Attribute which allows the same type to be added multiple times.
|
||||
/// </summary>
|
||||
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
|
||||
public class AllowDuplicateTypes : Attribute
|
||||
{
|
||||
// Intentionally left blank.
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user