You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1195 lines
50 KiB
1195 lines
50 KiB
// Snap Drop Zone|Prefabs|0080
|
|
namespace VRTK
|
|
{
|
|
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using Highlighters;
|
|
|
|
/// <summary>
|
|
/// Event Payload
|
|
/// </summary>
|
|
/// <param name="snappedObject">The interactable object that is dealing with the snap drop zone.</param>
|
|
public struct SnapDropZoneEventArgs
|
|
{
|
|
public GameObject snappedObject;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Event Payload
|
|
/// </summary>
|
|
/// <param name="sender">this object</param>
|
|
/// <param name="e"><see cref="SnapDropZoneEventArgs"/></param>
|
|
public delegate void SnapDropZoneEventHandler(object sender, SnapDropZoneEventArgs e);
|
|
|
|
/// <summary>
|
|
/// Provides a predefined zone where a valid interactable object can be dropped and upon dropping it snaps to the set snap drop zone transform position, rotation and scale.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// **Prefab Usage:**
|
|
/// * Place the `VRTK/Prefabs/SnapDropZone/SnapDropZone` prefab into the scene hierarchy.
|
|
/// * Provide the SnapDropZone with an optional `Highlight Object Prefab` to generate an object outline in the scene that determines the final position, rotation and scale of the snapped object.
|
|
/// * If no `VRTK_BaseHighlighter` derivative is applied to the SnapDropZone then the default MaterialColorSwap Highlighter will be used.
|
|
/// * The collision zone that activates the SnapDropZone is a `Sphere Collider` by default but can be amended or replaced on the SnapDropZone GameObject.
|
|
/// * If the `Use Joint` Snap Type is selected then a custom Joint component is required to be added to the `SnapDropZone` Game Object and upon release the interactable object's rigidbody will be linked to this joint as the `Connected Body`.
|
|
/// </remarks>
|
|
/// <example>
|
|
/// `VRTK/Examples/041_Controller_ObjectSnappingToDropZones` uses the `VRTK_SnapDropZone` prefab to set up pre-determined snap zones for a range of objects and demonstrates how only objects of certain types can be snapped into certain areas.
|
|
/// </example>
|
|
[ExecuteInEditMode]
|
|
public class VRTK_SnapDropZone : MonoBehaviour
|
|
{
|
|
/// <summary>
|
|
/// The types of snap on release available.
|
|
/// </summary>
|
|
public enum SnapTypes
|
|
{
|
|
/// <summary>
|
|
/// Will set the interactable object rigidbody to `isKinematic = true`.
|
|
/// </summary>
|
|
UseKinematic,
|
|
/// <summary>
|
|
/// Will attach the interactable object's rigidbody to the provided joint as it's `Connected Body`.
|
|
/// </summary>
|
|
UseJoint,
|
|
/// <summary>
|
|
/// Will set the SnapDropZone as the interactable object's parent and set it's rigidbody to `isKinematic = true`.
|
|
/// </summary>
|
|
UseParenting
|
|
}
|
|
|
|
[Tooltip("A game object that is used to draw the highlighted destination for within the drop zone. This object will also be created in the Editor for easy placement.")]
|
|
public GameObject highlightObjectPrefab;
|
|
[Tooltip("The Snap Type to apply when a valid interactable object is dropped within the snap zone.")]
|
|
public SnapTypes snapType = SnapTypes.UseKinematic;
|
|
[Tooltip("The amount of time it takes for the object being snapped to move into the new snapped position, rotation and scale.")]
|
|
public float snapDuration = 0f;
|
|
[Tooltip("If this is checked then the scaled size of the snap drop zone will be applied to the object that is snapped to it.")]
|
|
public bool applyScalingOnSnap = false;
|
|
[Tooltip("If this is checked then when the snapped object is unsnapped from the drop zone, a clone of the unsnapped object will be snapped back into the drop zone.")]
|
|
public bool cloneNewOnUnsnap = false;
|
|
[Tooltip("The colour to use when showing the snap zone is active. This is used as the highlight colour when no object is hovering but `Highlight Always Active` is true.")]
|
|
public Color highlightColor = Color.clear;
|
|
[Tooltip("The colour to use when showing the snap zone is active and a valid object is hovering. If this is `Color.clear` then the `Highlight Color` will be used.")]
|
|
public Color validHighlightColor = Color.clear;
|
|
[Tooltip("The highlight object will always be displayed when the snap drop zone is available even if a valid item isn't being hovered over.")]
|
|
public bool highlightAlwaysActive = false;
|
|
[Tooltip("A specified VRTK_PolicyList to use to determine which interactable objects will be snapped to the snap drop zone on release.")]
|
|
public VRTK_PolicyList validObjectListPolicy;
|
|
[Tooltip("If this is checked then the drop zone highlight section will be displayed in the scene editor window.")]
|
|
public bool displayDropZoneInEditor = true;
|
|
|
|
[Tooltip("The Interactable Object to snap into the dropzone when the drop zone is enabled. The Interactable Object must be valid in any given policy list to snap.")]
|
|
public VRTK_InteractableObject defaultSnappedInteractableObject;
|
|
|
|
[Header("Obsolete Settings")]
|
|
|
|
[System.Obsolete("`VRTK_SnapDropZone.defaultSnappedObject` has been replaced with the `VRTK_SnapDropZone.defaultSnappedInteractableObject`. This parameter will be removed in a future version of VRTK.")]
|
|
[ObsoleteInspector]
|
|
public GameObject defaultSnappedObject;
|
|
|
|
/// <summary>
|
|
/// Emitted when a valid interactable object enters the snap drop zone trigger collider.
|
|
/// </summary>
|
|
public event SnapDropZoneEventHandler ObjectEnteredSnapDropZone;
|
|
/// <summary>
|
|
/// Emitted when a valid interactable object exists the snap drop zone trigger collider.
|
|
/// </summary>
|
|
public event SnapDropZoneEventHandler ObjectExitedSnapDropZone;
|
|
/// <summary>
|
|
/// Emitted when an interactable object is successfully snapped into a drop zone.
|
|
/// </summary>
|
|
public event SnapDropZoneEventHandler ObjectSnappedToDropZone;
|
|
/// <summary>
|
|
/// Emitted when an interactable object is removed from a snapped drop zone.
|
|
/// </summary>
|
|
public event SnapDropZoneEventHandler ObjectUnsnappedFromDropZone;
|
|
|
|
protected GameObject previousPrefab;
|
|
protected GameObject highlightContainer;
|
|
protected GameObject highlightObject;
|
|
protected GameObject highlightEditorObject = null;
|
|
|
|
protected List<VRTK_InteractableObject> currentValidSnapInteractableObjects = new List<VRTK_InteractableObject>();
|
|
protected VRTK_InteractableObject currentSnappedObject = null;
|
|
protected GameObject objectToClone = null;
|
|
protected bool[] clonedObjectColliderStates = new bool[0];
|
|
|
|
protected bool willSnap = false;
|
|
protected bool isSnapped = false;
|
|
protected bool wasSnapped = false;
|
|
protected bool isHighlighted = false;
|
|
|
|
protected VRTK_BaseHighlighter objectHighlighter;
|
|
protected Coroutine transitionInPlaceRoutine;
|
|
protected Coroutine attemptTransitionAtEndOfFrameRoutine;
|
|
protected Coroutine checkCanSnapRoutine;
|
|
protected bool originalJointCollisionState = false;
|
|
|
|
protected Coroutine overridePreviousStateAtEndOfFrameRoutine;
|
|
|
|
protected const string HIGHLIGHT_CONTAINER_NAME = "HighlightContainer";
|
|
protected const string HIGHLIGHT_OBJECT_NAME = "HighlightObject";
|
|
protected const string HIGHLIGHT_EDITOR_OBJECT_NAME = "EditorHighlightObject";
|
|
|
|
public virtual void OnObjectEnteredSnapDropZone(SnapDropZoneEventArgs e)
|
|
{
|
|
if (ObjectEnteredSnapDropZone != null)
|
|
{
|
|
ObjectEnteredSnapDropZone(this, e);
|
|
}
|
|
}
|
|
|
|
public virtual void OnObjectExitedSnapDropZone(SnapDropZoneEventArgs e)
|
|
{
|
|
if (ObjectExitedSnapDropZone != null)
|
|
{
|
|
ObjectExitedSnapDropZone(this, e);
|
|
}
|
|
}
|
|
|
|
public virtual void OnObjectSnappedToDropZone(SnapDropZoneEventArgs e)
|
|
{
|
|
if (ObjectSnappedToDropZone != null)
|
|
{
|
|
ObjectSnappedToDropZone(this, e);
|
|
}
|
|
}
|
|
|
|
public virtual void OnObjectUnsnappedFromDropZone(SnapDropZoneEventArgs e)
|
|
{
|
|
UnsnapObject();
|
|
if (ObjectUnsnappedFromDropZone != null)
|
|
{
|
|
ObjectUnsnappedFromDropZone(this, e);
|
|
}
|
|
}
|
|
|
|
public virtual SnapDropZoneEventArgs SetSnapDropZoneEvent(GameObject interactableObject)
|
|
{
|
|
SnapDropZoneEventArgs e;
|
|
e.snappedObject = interactableObject;
|
|
return e;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The InitaliseHighlightObject method sets up the highlight object based on the given Highlight Object Prefab.
|
|
/// </summary>
|
|
/// <param name="removeOldObject">If this is set to true then it attempts to delete the old highlight object if it exists. Defaults to `false`</param>
|
|
public virtual void InitaliseHighlightObject(bool removeOldObject = false)
|
|
{
|
|
//force delete previous created highlight object
|
|
if (removeOldObject)
|
|
{
|
|
DeleteHighlightObject();
|
|
}
|
|
//Always remove editor highlight object at runtime
|
|
ChooseDestroyType(transform.Find(ObjectPath(HIGHLIGHT_EDITOR_OBJECT_NAME)));
|
|
highlightEditorObject = null;
|
|
|
|
GenerateObjects();
|
|
}
|
|
|
|
/// <summary>
|
|
/// the ForceSnap method attempts to automatically attach a valid GameObject to the snap drop zone.
|
|
/// </summary>
|
|
/// <param name="objectToSnap">The GameObject to attempt to snap.</param>
|
|
public virtual void ForceSnap(GameObject objectToSnap)
|
|
{
|
|
ForceSnap(objectToSnap.GetComponentInParent<VRTK_InteractableObject>());
|
|
}
|
|
|
|
/// <summary>
|
|
/// the ForceSnap method attempts to automatically attach a valid Interactable Object to the snap drop zone.
|
|
/// </summary>
|
|
/// <param name="objectToSnap">The Interactable Object to attempt to snap.</param>
|
|
protected virtual void ForceSnap(VRTK_InteractableObject interactableObjectToSnap)
|
|
{
|
|
if (interactableObjectToSnap != null)
|
|
{
|
|
if (attemptTransitionAtEndOfFrameRoutine != null)
|
|
{
|
|
StopCoroutine(attemptTransitionAtEndOfFrameRoutine);
|
|
}
|
|
|
|
if (checkCanSnapRoutine != null)
|
|
{
|
|
StopCoroutine(checkCanSnapRoutine);
|
|
}
|
|
|
|
if (interactableObjectToSnap.IsGrabbed())
|
|
{
|
|
interactableObjectToSnap.ForceStopInteracting();
|
|
}
|
|
|
|
if (gameObject.activeInHierarchy)
|
|
{
|
|
attemptTransitionAtEndOfFrameRoutine = StartCoroutine(AttemptForceSnapAtEndOfFrame(interactableObjectToSnap));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The ForceUnsnap method attempts to automatically remove the current snapped game object from the snap drop zone.
|
|
/// </summary>
|
|
public virtual void ForceUnsnap()
|
|
{
|
|
if (isSnapped && ValidSnapObject(currentSnappedObject, false))
|
|
{
|
|
currentSnappedObject.ToggleSnapDropZone(this, false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The ValidSnappableObjectIsHovering method determines if any valid objects are currently hovering in the snap drop zone area.
|
|
/// </summary>
|
|
/// <returns>Returns true if a valid object is currently in the snap drop zone area.</returns>
|
|
public virtual bool ValidSnappableObjectIsHovering()
|
|
{
|
|
for (int i = 0; i < currentValidSnapInteractableObjects.Count; i++)
|
|
{
|
|
if (currentValidSnapInteractableObjects[i].IsGrabbed())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The IsObjectHovering method determines if the given GameObject is currently howvering (but not snapped) in the snap drop zone area.
|
|
/// </summary>
|
|
/// <param name="checkObject">The GameObject to check to see if it's hovering in the snap drop zone area.</param>
|
|
/// <returns>Returns true if the given GameObject is hovering (but not snapped) in the snap drop zone area.</returns>
|
|
public virtual bool IsObjectHovering(GameObject checkObject)
|
|
{
|
|
VRTK_InteractableObject interactableObjectToCheck = checkObject.GetComponentInParent<VRTK_InteractableObject>();
|
|
return (interactableObjectToCheck != null ? currentValidSnapInteractableObjects.Contains(interactableObjectToCheck) : false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The IsInteractableObjectHovering method determines if the given Interactable Object script is currently howvering (but not snapped) in the snap drop zone area.
|
|
/// </summary>
|
|
/// <param name="checkObject">The Interactable Object script to check to see if it's hovering in the snap drop zone area.</param>
|
|
/// <returns>Returns true if the given Interactable Object script is hovering (but not snapped) in the snap drop zone area.</returns>
|
|
public virtual bool IsInteractableObjectHovering(VRTK_InteractableObject checkObject)
|
|
{
|
|
return (checkObject != null ? currentValidSnapInteractableObjects.Contains(checkObject) : false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The GetHoveringObjects method returns a List of valid GameObjects that are currently hovering (but not snapped) in the snap drop zone area.
|
|
/// </summary>
|
|
/// <returns>The List of valid GameObjects that are hovering (but not snapped) in the snap drop zone area.</returns>
|
|
public virtual List<GameObject> GetHoveringObjects()
|
|
{
|
|
List<GameObject> returnList = new List<GameObject>();
|
|
for (int i = 0; i < currentValidSnapInteractableObjects.Count; i++)
|
|
{
|
|
VRTK_SharedMethods.AddListValue(returnList, currentValidSnapInteractableObjects[i].gameObject);
|
|
}
|
|
return returnList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The GetHoveringInteractableObjects method returns a List of valid Interactable Object scripts that are currently hovering (but not snapped) in the snap drop zone area.
|
|
/// </summary>
|
|
/// <returns>The List of valid Interactable Object scripts that are hovering (but not snapped) in the snap drop zone area.</returns>
|
|
public virtual List<VRTK_InteractableObject> GetHoveringInteractableObjects()
|
|
{
|
|
return currentValidSnapInteractableObjects;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The GetCurrentSnappedObejct method returns the GameObject that is currently snapped in the snap drop zone area.
|
|
/// </summary>
|
|
/// <returns>The GameObject that is currently snapped in the snap drop zone area.</returns>
|
|
public virtual GameObject GetCurrentSnappedObject()
|
|
{
|
|
return (currentSnappedObject != null ? currentSnappedObject.gameObject : null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The GetCurrentSnappedInteractableObject method returns the Interactable Object script that is currently snapped in the snap drop zone area.
|
|
/// </summary>
|
|
/// <returns>The Interactable Object script that is currently snapped in the snap drop zone area.</returns>
|
|
public virtual VRTK_InteractableObject GetCurrentSnappedInteractableObject()
|
|
{
|
|
return currentSnappedObject;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The Clone method returns the GameObject of the cloned snap drop zone
|
|
/// </summary>
|
|
/// <param name="position">Position of the cloned GameObject</param>
|
|
/// <returns>The GameObject of the clone</returns>
|
|
public virtual GameObject Clone(Vector3 position)
|
|
{
|
|
VRTK_SnapDropZone cloneSDZ = Instantiate(gameObject, position, transform.rotation).GetComponent<VRTK_SnapDropZone>();
|
|
|
|
for (int childID = 0; childID < cloneSDZ.transform.childCount; childID++)
|
|
{
|
|
Transform child = cloneSDZ.transform.GetChild(childID);
|
|
if (child.GetComponent<VRTK_InteractableObject>() != null)
|
|
{
|
|
Destroy(child.gameObject);
|
|
}
|
|
}
|
|
|
|
if (isSnapped)
|
|
{
|
|
VRTK_InteractableObject currObject = currentSnappedObject;
|
|
|
|
//Get copy of Objects original state
|
|
Transform previousParent;
|
|
bool previousKinematic;
|
|
bool previousGrabbable;
|
|
currObject.GetPreviousState(out previousParent, out previousKinematic, out previousGrabbable);
|
|
|
|
GameObject clonedObject = null;
|
|
if (cloneNewOnUnsnap)
|
|
{
|
|
clonedObject = Instantiate(objectToClone);
|
|
clonedObject.SetActive(true);
|
|
}
|
|
else
|
|
{
|
|
clonedObject = Instantiate(currObject.gameObject);
|
|
}
|
|
|
|
clonedObject.transform.position = cloneSDZ.transform.position;
|
|
cloneSDZ.ForceSnap(clonedObject);
|
|
|
|
overridePreviousStateAtEndOfFrameRoutine = StartCoroutine(OverridePreviousStateAtEndOfFrame(clonedObject.GetComponent<VRTK_InteractableObject>(), previousParent, previousKinematic, previousGrabbable));
|
|
}
|
|
|
|
return cloneSDZ.gameObject;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The Clone method returns the GameObject of the cloned snap drop zone
|
|
/// </summary>
|
|
/// <returns>The GameObject of the clone</returns>
|
|
public virtual GameObject Clone()
|
|
{
|
|
return Clone(Vector3.zero);
|
|
}
|
|
|
|
protected virtual void Awake()
|
|
{
|
|
if (Application.isPlaying)
|
|
{
|
|
InitaliseHighlightObject();
|
|
}
|
|
}
|
|
|
|
protected virtual void OnApplicationQuit()
|
|
{
|
|
if (objectHighlighter != null)
|
|
{
|
|
objectHighlighter.Unhighlight();
|
|
}
|
|
}
|
|
|
|
protected virtual void OnEnable()
|
|
{
|
|
currentValidSnapInteractableObjects.Clear();
|
|
currentSnappedObject = null;
|
|
objectToClone = null;
|
|
clonedObjectColliderStates = new bool[0];
|
|
willSnap = false;
|
|
isSnapped = false;
|
|
wasSnapped = false;
|
|
isHighlighted = false;
|
|
|
|
#pragma warning disable 618
|
|
if (defaultSnappedObject != null && defaultSnappedInteractableObject == null)
|
|
{
|
|
defaultSnappedInteractableObject = defaultSnappedObject.GetComponentInParent<VRTK_InteractableObject>();
|
|
}
|
|
#pragma warning restore 618
|
|
|
|
DisableHighlightShadows();
|
|
if (!VRTK_SharedMethods.IsEditTime() && Application.isPlaying && defaultSnappedInteractableObject != null)
|
|
{
|
|
ForceSnap(defaultSnappedInteractableObject);
|
|
}
|
|
}
|
|
|
|
protected virtual void OnDisable()
|
|
{
|
|
if (transitionInPlaceRoutine != null)
|
|
{
|
|
StopCoroutine(transitionInPlaceRoutine);
|
|
}
|
|
|
|
if (attemptTransitionAtEndOfFrameRoutine != null)
|
|
{
|
|
StopCoroutine(attemptTransitionAtEndOfFrameRoutine);
|
|
}
|
|
|
|
if (checkCanSnapRoutine != null)
|
|
{
|
|
StopCoroutine(checkCanSnapRoutine);
|
|
}
|
|
|
|
if(overridePreviousStateAtEndOfFrameRoutine != null)
|
|
{
|
|
StopCoroutine(overridePreviousStateAtEndOfFrameRoutine);
|
|
}
|
|
|
|
ForceUnsnap();
|
|
SetHighlightObjectActive(false);
|
|
UnregisterAllUngrabEvents();
|
|
}
|
|
|
|
protected virtual void Update()
|
|
{
|
|
CheckSnappedItemExists();
|
|
CheckPrefabUpdate();
|
|
CreateHighlightersInEditor();
|
|
CheckCurrentValidSnapObjectStillValid();
|
|
previousPrefab = highlightObjectPrefab;
|
|
SetObjectHighlight();
|
|
}
|
|
|
|
protected virtual void OnTriggerEnter(Collider collider)
|
|
{
|
|
CheckCanSnap(collider.GetComponentInParent<VRTK_InteractableObject>());
|
|
}
|
|
|
|
protected virtual void OnTriggerExit(Collider collider)
|
|
{
|
|
CheckCanUnsnap(collider.GetComponentInParent<VRTK_InteractableObject>());
|
|
}
|
|
|
|
protected virtual void CheckCanSnap(VRTK_InteractableObject interactableObjectCheck)
|
|
{
|
|
if (interactableObjectCheck != null && ValidSnapObject(interactableObjectCheck, true))
|
|
{
|
|
AddCurrentValidSnapObject(interactableObjectCheck);
|
|
if (!isSnapped)
|
|
{
|
|
ToggleHighlight(interactableObjectCheck, true);
|
|
interactableObjectCheck.SetSnapDropZoneHover(this, true);
|
|
if (!willSnap)
|
|
{
|
|
OnObjectEnteredSnapDropZone(SetSnapDropZoneEvent(interactableObjectCheck.gameObject));
|
|
}
|
|
willSnap = true;
|
|
ToggleHighlightColor();
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void CheckCanUnsnap(VRTK_InteractableObject interactableObjectCheck)
|
|
{
|
|
if (interactableObjectCheck != null && currentValidSnapInteractableObjects.Contains(interactableObjectCheck) && ValidUnsnap(interactableObjectCheck))
|
|
{
|
|
if (isSnapped && currentSnappedObject == interactableObjectCheck)
|
|
{
|
|
ForceUnsnap();
|
|
}
|
|
|
|
RemoveCurrentValidSnapObject(interactableObjectCheck);
|
|
|
|
if (!ValidSnappableObjectIsHovering())
|
|
{
|
|
ToggleHighlight(interactableObjectCheck, false);
|
|
willSnap = false;
|
|
}
|
|
|
|
interactableObjectCheck.SetSnapDropZoneHover(this, false);
|
|
|
|
if (ValidSnapObject(interactableObjectCheck, true))
|
|
{
|
|
ToggleHighlightColor();
|
|
OnObjectExitedSnapDropZone(SetSnapDropZoneEvent(interactableObjectCheck.gameObject));
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual bool ValidUnsnap(VRTK_InteractableObject interactableObjectCheck)
|
|
{
|
|
return (interactableObjectCheck.IsGrabbed() || ((snapType != SnapTypes.UseJoint || !float.IsInfinity(GetComponent<Joint>().breakForce)) && interactableObjectCheck.validDrop == VRTK_InteractableObject.ValidDropTypes.DropAnywhere));
|
|
}
|
|
|
|
protected virtual void SnapObjectToZone(VRTK_InteractableObject objectToSnap)
|
|
{
|
|
if (!isSnapped && ValidSnapObject(objectToSnap, false))
|
|
{
|
|
SnapObject(objectToSnap);
|
|
}
|
|
}
|
|
|
|
protected virtual void UnregisterAllUngrabEvents()
|
|
{
|
|
for (int i = 0; i < currentValidSnapInteractableObjects.Count; i++)
|
|
{
|
|
currentValidSnapInteractableObjects[i].InteractableObjectGrabbed -= InteractableObjectGrabbed;
|
|
currentValidSnapInteractableObjects[i].InteractableObjectUngrabbed -= InteractableObjectUngrabbed;
|
|
}
|
|
}
|
|
|
|
protected virtual bool ValidSnapObject(VRTK_InteractableObject interactableObjectCheck, bool grabState, bool checkGrabState = true)
|
|
{
|
|
return (interactableObjectCheck != null && (!checkGrabState || interactableObjectCheck.IsGrabbed() == grabState) && !VRTK_PolicyList.Check(interactableObjectCheck.gameObject, validObjectListPolicy));
|
|
}
|
|
|
|
protected virtual string ObjectPath(string name)
|
|
{
|
|
return HIGHLIGHT_CONTAINER_NAME + "/" + name;
|
|
}
|
|
|
|
protected virtual void CheckSnappedItemExists()
|
|
{
|
|
if (isSnapped && (currentSnappedObject == null || !currentSnappedObject.gameObject.activeInHierarchy))
|
|
{
|
|
ForceUnsnap();
|
|
OnObjectUnsnappedFromDropZone(SetSnapDropZoneEvent((currentSnappedObject != null ? currentSnappedObject.gameObject : null)));
|
|
}
|
|
}
|
|
|
|
protected virtual void CheckPrefabUpdate()
|
|
{
|
|
//If the highlightObjectPrefab has changed then delete the highlight object in preparation to create a new one
|
|
if (previousPrefab != null && previousPrefab != highlightObjectPrefab)
|
|
{
|
|
DeleteHighlightObject();
|
|
}
|
|
}
|
|
|
|
protected virtual void SetObjectHighlight()
|
|
{
|
|
if (highlightAlwaysActive && !isSnapped && !isHighlighted)
|
|
{
|
|
SetHighlightObjectActive(true);
|
|
ToggleHighlightColor();
|
|
}
|
|
|
|
if (!highlightAlwaysActive && isHighlighted && !ValidSnappableObjectIsHovering())
|
|
{
|
|
SetHighlightObjectActive(false);
|
|
}
|
|
}
|
|
|
|
protected virtual void ToggleHighlightColor()
|
|
{
|
|
if (Application.isPlaying && highlightAlwaysActive && !isSnapped && objectHighlighter != null)
|
|
{
|
|
objectHighlighter.Highlight((willSnap && validHighlightColor != Color.clear ? validHighlightColor : highlightColor));
|
|
}
|
|
}
|
|
|
|
protected virtual void CreateHighlightersInEditor()
|
|
{
|
|
if (VRTK_SharedMethods.IsEditTime())
|
|
{
|
|
GenerateHighlightObject();
|
|
|
|
if (snapType == SnapTypes.UseJoint && GetComponent<Joint>() == null)
|
|
{
|
|
VRTK_Logger.Warn(VRTK_Logger.GetCommonMessage(VRTK_Logger.CommonMessageKeys.REQUIRED_COMPONENT_MISSING_FROM_GAMEOBJECT, "SnapDropZone:" + name, "Joint", "the same", " because the `Snap Type` is set to `Use Joint`"));
|
|
}
|
|
|
|
GenerateEditorHighlightObject();
|
|
ForceSetObjects();
|
|
if (highlightEditorObject != null)
|
|
{
|
|
highlightEditorObject.SetActive(displayDropZoneInEditor);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void CheckCurrentValidSnapObjectStillValid()
|
|
{
|
|
for (int i = 0; i < currentValidSnapInteractableObjects.Count; i++)
|
|
{
|
|
VRTK_InteractableObject interactableObjectCheck = currentValidSnapInteractableObjects[i];
|
|
//if the interactable object associated with it has been snapped to another zone, then unset the current valid snap object
|
|
if (interactableObjectCheck != null && interactableObjectCheck.GetStoredSnapDropZone() != null && interactableObjectCheck.GetStoredSnapDropZone() != this)
|
|
{
|
|
RemoveCurrentValidSnapObject(interactableObjectCheck);
|
|
if (isHighlighted && highlightObject != null && !highlightAlwaysActive)
|
|
{
|
|
SetHighlightObjectActive(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void ForceSetObjects()
|
|
{
|
|
if (highlightEditorObject == null)
|
|
{
|
|
Transform forceFindHighlightEditorObject = transform.Find(ObjectPath(HIGHLIGHT_EDITOR_OBJECT_NAME));
|
|
highlightEditorObject = (forceFindHighlightEditorObject ? forceFindHighlightEditorObject.gameObject : null);
|
|
}
|
|
|
|
if (highlightObject == null)
|
|
{
|
|
Transform forceFindHighlightObject = transform.Find(ObjectPath(HIGHLIGHT_OBJECT_NAME));
|
|
highlightObject = (forceFindHighlightObject ? forceFindHighlightObject.gameObject : null);
|
|
}
|
|
|
|
if (highlightContainer == null)
|
|
{
|
|
Transform forceFindHighlightContainer = transform.Find(HIGHLIGHT_CONTAINER_NAME);
|
|
highlightContainer = (forceFindHighlightContainer ? forceFindHighlightContainer.gameObject : null);
|
|
}
|
|
}
|
|
|
|
protected virtual void GenerateContainer()
|
|
{
|
|
if (highlightContainer == null || transform.Find(HIGHLIGHT_CONTAINER_NAME) == null)
|
|
{
|
|
highlightContainer = new GameObject(HIGHLIGHT_CONTAINER_NAME);
|
|
highlightContainer.transform.SetParent(transform);
|
|
highlightContainer.transform.localPosition = Vector3.zero;
|
|
highlightContainer.transform.localRotation = Quaternion.identity;
|
|
highlightContainer.transform.localScale = Vector3.one;
|
|
}
|
|
}
|
|
|
|
protected virtual void DisableHighlightShadows()
|
|
{
|
|
if (highlightObject != null)
|
|
{
|
|
Renderer[] foundRenderers = highlightObject.GetComponentsInChildren<Renderer>(true);
|
|
for (int i = 0; i < foundRenderers.Length; i++)
|
|
{
|
|
foundRenderers[i].receiveShadows = false;
|
|
foundRenderers[i].shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void SetContainer()
|
|
{
|
|
Transform findContainer = transform.Find(HIGHLIGHT_CONTAINER_NAME);
|
|
if (findContainer != null)
|
|
{
|
|
highlightContainer = findContainer.gameObject;
|
|
}
|
|
}
|
|
|
|
protected virtual void GenerateObjects()
|
|
{
|
|
GenerateHighlightObject();
|
|
if (highlightObject != null && objectHighlighter == null)
|
|
{
|
|
InitialiseHighlighter();
|
|
}
|
|
}
|
|
|
|
protected virtual void SnapObject(VRTK_InteractableObject interactableObjectCheck)
|
|
{
|
|
//If the item is in a snappable position and this drop zone isn't snapped and the collider is a valid interactable object
|
|
if (willSnap && !isSnapped && ValidSnapObject(interactableObjectCheck, false))
|
|
{
|
|
//Only snap it to the drop zone if it's not already in a drop zone
|
|
if (!interactableObjectCheck.IsInSnapDropZone())
|
|
{
|
|
if (highlightObject != null)
|
|
{
|
|
//Turn off the drop zone highlighter
|
|
SetHighlightObjectActive(false);
|
|
}
|
|
|
|
Vector3 newLocalScale = GetNewLocalScale(interactableObjectCheck);
|
|
if (transitionInPlaceRoutine != null)
|
|
{
|
|
StopCoroutine(transitionInPlaceRoutine);
|
|
}
|
|
|
|
isSnapped = true;
|
|
currentSnappedObject = interactableObjectCheck;
|
|
if (cloneNewOnUnsnap)
|
|
{
|
|
CreatePermanentClone();
|
|
}
|
|
|
|
if (gameObject.activeInHierarchy)
|
|
{
|
|
transitionInPlaceRoutine = StartCoroutine(UpdateTransformDimensions(interactableObjectCheck, highlightContainer, newLocalScale, snapDuration));
|
|
}
|
|
|
|
interactableObjectCheck.ToggleSnapDropZone(this, true);
|
|
}
|
|
}
|
|
|
|
//Force reset isSnapped if the item is grabbed but isSnapped is still true
|
|
isSnapped = (isSnapped && interactableObjectCheck != null && interactableObjectCheck.IsGrabbed() ? false : isSnapped);
|
|
willSnap = !isSnapped;
|
|
wasSnapped = false;
|
|
}
|
|
|
|
protected virtual void CreatePermanentClone()
|
|
{
|
|
VRTK_BaseHighlighter currentSnappedObjectHighlighter = currentSnappedObject.GetComponent<VRTK_BaseHighlighter>();
|
|
if (currentSnappedObjectHighlighter != null)
|
|
{
|
|
currentSnappedObjectHighlighter.Unhighlight();
|
|
}
|
|
objectToClone = Instantiate(currentSnappedObject.gameObject);
|
|
objectToClone.transform.position = highlightContainer.transform.position;
|
|
objectToClone.transform.rotation = highlightContainer.transform.rotation;
|
|
Collider[] clonedObjectStates = currentSnappedObject.GetComponentsInChildren<Collider>();
|
|
clonedObjectColliderStates = new bool[clonedObjectStates.Length];
|
|
for (int i = 0; i < clonedObjectStates.Length; i++)
|
|
{
|
|
Collider clonedObjectColliderState = clonedObjectStates[i];
|
|
clonedObjectColliderStates[i] = clonedObjectColliderState.isTrigger;
|
|
clonedObjectColliderState.isTrigger = true;
|
|
}
|
|
objectToClone.SetActive(false);
|
|
}
|
|
|
|
protected virtual void ResetPermanentCloneColliders(GameObject objectToReset)
|
|
{
|
|
if (objectToReset != null && clonedObjectColliderStates.Length > 0)
|
|
{
|
|
Collider[] clonedObjectStates = objectToReset.GetComponentsInChildren<Collider>();
|
|
for (int i = 0; i < clonedObjectStates.Length; i++)
|
|
{
|
|
Collider clonedObjectColliderState = clonedObjectStates[i];
|
|
if (clonedObjectColliderStates.Length > i)
|
|
{
|
|
clonedObjectColliderState.isTrigger = clonedObjectColliderStates[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void ResnapPermanentClone()
|
|
{
|
|
if (objectToClone != null)
|
|
{
|
|
float savedSnapDuration = snapDuration;
|
|
snapDuration = 0f;
|
|
objectToClone.SetActive(true);
|
|
ResetPermanentCloneColliders(objectToClone);
|
|
ForceSnap(objectToClone);
|
|
snapDuration = savedSnapDuration;
|
|
}
|
|
}
|
|
|
|
protected virtual void UnsnapObject()
|
|
{
|
|
if (currentSnappedObject != null)
|
|
{
|
|
ResetPermanentCloneColliders(currentSnappedObject.gameObject);
|
|
RemoveCurrentValidSnapObject(currentSnappedObject);
|
|
}
|
|
|
|
isSnapped = false;
|
|
wasSnapped = true;
|
|
VRTK_InteractableObject checkCanSnapObject = currentSnappedObject;
|
|
currentSnappedObject = null;
|
|
ResetSnapDropZoneJoint();
|
|
|
|
if (transitionInPlaceRoutine != null)
|
|
{
|
|
StopCoroutine(transitionInPlaceRoutine);
|
|
}
|
|
|
|
if (cloneNewOnUnsnap)
|
|
{
|
|
ResnapPermanentClone();
|
|
}
|
|
|
|
if (checkCanSnapRoutine != null)
|
|
{
|
|
StopCoroutine(checkCanSnapRoutine);
|
|
}
|
|
|
|
if (gameObject.activeInHierarchy)
|
|
{
|
|
checkCanSnapRoutine = StartCoroutine(CheckCanSnapObjectAtEndOfFrame(checkCanSnapObject));
|
|
}
|
|
checkCanSnapObject = null;
|
|
}
|
|
|
|
protected virtual Vector3 GetNewLocalScale(VRTK_InteractableObject checkObject)
|
|
{
|
|
// If apply scaling is checked then use the drop zone scale to resize the object
|
|
Vector3 newLocalScale = checkObject.transform.localScale;
|
|
if (applyScalingOnSnap)
|
|
{
|
|
checkObject.StoreLocalScale();
|
|
newLocalScale = Vector3.Scale(checkObject.transform.localScale, transform.localScale);
|
|
}
|
|
return newLocalScale;
|
|
}
|
|
|
|
protected virtual IEnumerator CheckCanSnapObjectAtEndOfFrame(VRTK_InteractableObject interactableObjectCheck)
|
|
{
|
|
yield return new WaitForEndOfFrame();
|
|
CheckCanSnap(interactableObjectCheck);
|
|
}
|
|
|
|
protected virtual IEnumerator UpdateTransformDimensions(VRTK_InteractableObject ioCheck, GameObject endSettings, Vector3 endScale, float duration)
|
|
{
|
|
float elapsedTime = 0f;
|
|
Transform ioTransform = ioCheck.transform;
|
|
Vector3 startPosition = ioTransform.position;
|
|
Quaternion startRotation = ioTransform.rotation;
|
|
Vector3 startScale = ioTransform.localScale;
|
|
bool storedKinematicState = ioCheck.isKinematic;
|
|
ioCheck.isKinematic = true;
|
|
while (elapsedTime <= duration)
|
|
{
|
|
elapsedTime += Time.deltaTime;
|
|
if (ioTransform != null && endSettings != null)
|
|
{
|
|
ioTransform.position = Vector3.Lerp(startPosition, endSettings.transform.position, (elapsedTime / duration));
|
|
ioTransform.rotation = Quaternion.Lerp(startRotation, endSettings.transform.rotation, (elapsedTime / duration));
|
|
ioTransform.localScale = Vector3.Lerp(startScale, endScale, (elapsedTime / duration));
|
|
}
|
|
yield return null;
|
|
}
|
|
|
|
if (ioTransform != null && endSettings != null)
|
|
{
|
|
//Force all to the last setting in case anything has moved during the transition
|
|
ioTransform.position = endSettings.transform.position;
|
|
ioTransform.rotation = endSettings.transform.rotation;
|
|
ioTransform.localScale = endScale;
|
|
}
|
|
|
|
ioCheck.isKinematic = storedKinematicState;
|
|
SetDropSnapType(ioCheck);
|
|
}
|
|
|
|
protected virtual void SetDropSnapType(VRTK_InteractableObject ioCheck)
|
|
{
|
|
switch (snapType)
|
|
{
|
|
case SnapTypes.UseKinematic:
|
|
ioCheck.SaveCurrentState();
|
|
ioCheck.isKinematic = true;
|
|
break;
|
|
case SnapTypes.UseParenting:
|
|
ioCheck.SaveCurrentState();
|
|
ioCheck.isKinematic = true;
|
|
ioCheck.transform.SetParent(transform);
|
|
break;
|
|
case SnapTypes.UseJoint:
|
|
SetSnapDropZoneJoint(ioCheck.GetComponent<Rigidbody>());
|
|
break;
|
|
}
|
|
OnObjectSnappedToDropZone(SetSnapDropZoneEvent(ioCheck.gameObject));
|
|
}
|
|
|
|
protected virtual void SetSnapDropZoneJoint(Rigidbody snapTo)
|
|
{
|
|
Joint snapDropZoneJoint = GetComponent<Joint>();
|
|
if (snapDropZoneJoint == null)
|
|
{
|
|
VRTK_Logger.Error(VRTK_Logger.GetCommonMessage(VRTK_Logger.CommonMessageKeys.REQUIRED_COMPONENT_MISSING_FROM_GAMEOBJECT, "SnapDropZone:" + name, "Joint", "the same", " because the `Snap Type` is set to `Use Joint`"));
|
|
return;
|
|
}
|
|
if (snapTo == null)
|
|
{
|
|
VRTK_Logger.Error(VRTK_Logger.GetCommonMessage(VRTK_Logger.CommonMessageKeys.REQUIRED_COMPONENT_MISSING_FROM_GAMEOBJECT, "VRTK_SnapDropZone", "Rigidbody", "the `VRTK_InteractableObject`"));
|
|
return;
|
|
}
|
|
|
|
snapDropZoneJoint.connectedBody = snapTo;
|
|
originalJointCollisionState = snapDropZoneJoint.enableCollision;
|
|
//need to set this to true otherwise highlighting doesn't work again on grab
|
|
snapDropZoneJoint.enableCollision = true;
|
|
}
|
|
|
|
protected virtual void ResetSnapDropZoneJoint()
|
|
{
|
|
Joint snapDropZoneJoint = GetComponent<Joint>();
|
|
if (snapDropZoneJoint != null)
|
|
{
|
|
snapDropZoneJoint.enableCollision = originalJointCollisionState;
|
|
}
|
|
}
|
|
|
|
protected virtual void AddCurrentValidSnapObject(VRTK_InteractableObject givenObject)
|
|
{
|
|
if (givenObject != null)
|
|
{
|
|
if (VRTK_SharedMethods.AddListValue(currentValidSnapInteractableObjects, givenObject, true))
|
|
{
|
|
givenObject.InteractableObjectGrabbed += InteractableObjectGrabbed;
|
|
givenObject.InteractableObjectUngrabbed += InteractableObjectUngrabbed;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void RemoveCurrentValidSnapObject(VRTK_InteractableObject givenObject)
|
|
{
|
|
if (givenObject != null)
|
|
{
|
|
if (currentValidSnapInteractableObjects.Remove(givenObject))
|
|
{
|
|
givenObject.InteractableObjectGrabbed -= InteractableObjectGrabbed;
|
|
givenObject.InteractableObjectUngrabbed -= InteractableObjectUngrabbed;
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void InteractableObjectGrabbed(object sender, InteractableObjectEventArgs e)
|
|
{
|
|
VRTK_InteractableObject grabbedInteractableObject = sender as VRTK_InteractableObject;
|
|
if (!grabbedInteractableObject.IsInSnapDropZone())
|
|
{
|
|
CheckCanSnap(grabbedInteractableObject);
|
|
}
|
|
}
|
|
|
|
protected virtual void InteractableObjectUngrabbed(object sender, InteractableObjectEventArgs e)
|
|
{
|
|
VRTK_InteractableObject releasedInteractableObject = sender as VRTK_InteractableObject;
|
|
if (attemptTransitionAtEndOfFrameRoutine != null)
|
|
{
|
|
StopCoroutine(attemptTransitionAtEndOfFrameRoutine);
|
|
}
|
|
attemptTransitionAtEndOfFrameRoutine = StartCoroutine(AttemptForceSnapAtEndOfFrame(releasedInteractableObject));
|
|
}
|
|
|
|
protected virtual void AttemptForceSnap(VRTK_InteractableObject objectToSnap)
|
|
{
|
|
//force snap settings on
|
|
willSnap = true;
|
|
//Force touch one of the object's colliders on this trigger collider
|
|
SnapObjectToZone(objectToSnap);
|
|
}
|
|
|
|
protected virtual IEnumerator AttemptForceSnapAtEndOfFrame(VRTK_InteractableObject objectToSnap)
|
|
{
|
|
yield return new WaitForEndOfFrame();
|
|
objectToSnap.SaveCurrentState();
|
|
AttemptForceSnap(objectToSnap);
|
|
}
|
|
|
|
protected virtual void ToggleHighlight(VRTK_InteractableObject checkObject, bool state)
|
|
{
|
|
if (highlightObject != null && ValidSnapObject(checkObject, true, state))
|
|
{
|
|
//Toggle the highlighter state
|
|
SetHighlightObjectActive(state);
|
|
}
|
|
}
|
|
|
|
protected virtual void CopyObject(GameObject objectBlueprint, ref GameObject clonedObject, string givenName)
|
|
{
|
|
GenerateContainer();
|
|
Vector3 saveScale = transform.localScale;
|
|
transform.localScale = Vector3.one;
|
|
|
|
clonedObject = Instantiate(objectBlueprint, highlightContainer.transform) as GameObject;
|
|
clonedObject.name = givenName;
|
|
|
|
//default position of new highlight object
|
|
clonedObject.transform.localPosition = Vector3.zero;
|
|
clonedObject.transform.localRotation = Quaternion.identity;
|
|
|
|
transform.localScale = saveScale;
|
|
CleanHighlightObject(clonedObject);
|
|
}
|
|
|
|
protected virtual void GenerateHighlightObject()
|
|
{
|
|
//If there is a given highlight prefab and no existing highlight object then create a new highlight object
|
|
if (highlightObjectPrefab != null && highlightObject == null && transform.Find(ObjectPath(HIGHLIGHT_OBJECT_NAME)) == null)
|
|
{
|
|
CopyObject(highlightObjectPrefab, ref highlightObject, HIGHLIGHT_OBJECT_NAME);
|
|
}
|
|
|
|
//if highlight object exists but not in the variable then force grab it
|
|
Transform checkForChild = transform.Find(ObjectPath(HIGHLIGHT_OBJECT_NAME));
|
|
if (checkForChild != null && highlightObject == null)
|
|
{
|
|
highlightObject = checkForChild.gameObject;
|
|
}
|
|
|
|
//if no highlight object prefab is set but a highlight object is found then destroy the highlight object
|
|
if (highlightObjectPrefab == null && highlightObject != null)
|
|
{
|
|
DeleteHighlightObject();
|
|
}
|
|
|
|
DisableHighlightShadows();
|
|
SetHighlightObjectActive(false);
|
|
SetContainer();
|
|
}
|
|
|
|
protected virtual void SetHighlightObjectActive(bool state)
|
|
{
|
|
if (highlightObject != null)
|
|
{
|
|
highlightObject.SetActive(state);
|
|
isHighlighted = state;
|
|
}
|
|
}
|
|
|
|
protected virtual void DeleteHighlightObject()
|
|
{
|
|
ChooseDestroyType(transform.Find(HIGHLIGHT_CONTAINER_NAME));
|
|
highlightContainer = null;
|
|
highlightObject = null;
|
|
objectHighlighter = null;
|
|
}
|
|
|
|
protected virtual void GenerateEditorHighlightObject()
|
|
{
|
|
if (highlightObject != null && highlightEditorObject == null && transform.Find(ObjectPath(HIGHLIGHT_EDITOR_OBJECT_NAME)) == null)
|
|
{
|
|
CopyObject(highlightObject, ref highlightEditorObject, HIGHLIGHT_EDITOR_OBJECT_NAME);
|
|
Renderer[] renderers = highlightEditorObject.GetComponentsInChildren<Renderer>();
|
|
for (int i = 0; i < renderers.Length; i++)
|
|
{
|
|
renderers[i].material = Resources.Load("SnapDropZoneEditorObject") as Material;
|
|
}
|
|
highlightEditorObject.SetActive(true);
|
|
}
|
|
}
|
|
|
|
protected virtual void CleanHighlightObject(GameObject objectToClean)
|
|
{
|
|
//If the highlight object has any child snap zones, then force delete these
|
|
VRTK_SnapDropZone[] deleteSnapZones = objectToClean.GetComponentsInChildren<VRTK_SnapDropZone>(true);
|
|
for (int i = 0; i < deleteSnapZones.Length; i++)
|
|
{
|
|
ChooseDestroyType(deleteSnapZones[i].gameObject);
|
|
}
|
|
|
|
//determine components that shouldn't be deleted from highlight object
|
|
string[] validComponents = new string[] { "Transform", "MeshFilter", "MeshRenderer", "SkinnedMeshRenderer", "VRTK_GameObjectLinker" };
|
|
|
|
//First clean out the joints cause RigidBodys depends on them.
|
|
Joint[] joints = objectToClean.GetComponentsInChildren<Joint>(true);
|
|
for (int i = 0; i < joints.Length; i++)
|
|
{
|
|
ChooseDestroyType(joints[i]);
|
|
}
|
|
|
|
//Go through all of the components on the highlighted object and delete any components that aren't in the valid component list
|
|
Component[] components = objectToClean.GetComponentsInChildren<Component>(true);
|
|
for (int i = 0; i < components.Length; i++)
|
|
{
|
|
Component component = components[i];
|
|
bool valid = false;
|
|
|
|
//Loop through each valid component and check to see if this component is valid
|
|
for (int j = 0; j < validComponents.Length; j++)
|
|
{
|
|
//if it's a valid component then break the check
|
|
if (component.GetType().ToString().Contains("." + validComponents[j]))
|
|
{
|
|
valid = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//if this is a valid component then just continue to the next component
|
|
if (valid)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//If not a valid component then delete it
|
|
ChooseDestroyType(component);
|
|
}
|
|
}
|
|
|
|
protected virtual void InitialiseHighlighter()
|
|
{
|
|
VRTK_BaseHighlighter existingHighlighter = VRTK_BaseHighlighter.GetActiveHighlighter(gameObject);
|
|
//If no highlighter is found on the GameObject then create the default one
|
|
if (existingHighlighter == null)
|
|
{
|
|
highlightObject.AddComponent<VRTK_MaterialColorSwapHighlighter>();
|
|
}
|
|
else
|
|
{
|
|
VRTK_SharedMethods.CloneComponent(existingHighlighter, highlightObject);
|
|
}
|
|
|
|
//Initialise highlighter and set highlight colour
|
|
objectHighlighter = highlightObject.GetComponent<VRTK_BaseHighlighter>();
|
|
objectHighlighter.unhighlightOnDisable = false;
|
|
objectHighlighter.Initialise(highlightColor);
|
|
objectHighlighter.Highlight(highlightColor);
|
|
|
|
//if the object highlighter is using a cloned object then disable the created highlight object's renderers
|
|
if (objectHighlighter.UsesClonedObject())
|
|
{
|
|
Renderer[] renderers = GetComponentsInChildren<Renderer>(true);
|
|
for (int i = 0; i < renderers.Length; i++)
|
|
{
|
|
if (!VRTK_PlayerObject.IsPlayerObject(renderers[i].gameObject, VRTK_PlayerObject.ObjectTypes.Highlighter))
|
|
{
|
|
renderers[i].enabled = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void ChooseDestroyType(Transform deleteTransform)
|
|
{
|
|
if (deleteTransform != null)
|
|
{
|
|
ChooseDestroyType(deleteTransform.gameObject);
|
|
}
|
|
}
|
|
|
|
protected virtual void ChooseDestroyType(GameObject deleteObject)
|
|
{
|
|
if (VRTK_SharedMethods.IsEditTime())
|
|
{
|
|
if (deleteObject != null)
|
|
{
|
|
DestroyImmediate(deleteObject);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (deleteObject != null)
|
|
{
|
|
Destroy(deleteObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void ChooseDestroyType(Component deleteComponent)
|
|
{
|
|
if (VRTK_SharedMethods.IsEditTime())
|
|
{
|
|
if (deleteComponent != null)
|
|
{
|
|
DestroyImmediate(deleteComponent);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (deleteComponent != null)
|
|
{
|
|
Destroy(deleteComponent);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void OnDrawGizmosSelected()
|
|
{
|
|
if (highlightObject != null && !displayDropZoneInEditor)
|
|
{
|
|
Vector3 boxSize = VRTK_SharedMethods.GetBounds(highlightObject.transform).size * 1.05f;
|
|
Gizmos.color = Color.red;
|
|
Gizmos.DrawWireCube(highlightObject.transform.position, boxSize);
|
|
}
|
|
}
|
|
|
|
protected virtual IEnumerator OverridePreviousStateAtEndOfFrame(VRTK_InteractableObject io, Transform parent, bool kinematic, bool grabbable)
|
|
{
|
|
yield return new WaitForEndOfFrame();
|
|
io.OverridePreviousState(parent, kinematic, grabbable);
|
|
}
|
|
}
|
|
}
|