////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void UpdateData(HoverCursorDataProvider pCursorDataProv,
HoverInputOculusTouch.ControlState pState, OvrAvatar pAvatar)
{
ICursorDataForInput data = GetData(pCursorDataProv);
if (data == null)
{
return;
}
data.SetUsedByInput(pState.IsValid);
if (!pState.IsValid)
{
return;
}
if (!TryUpdateDataWithAvatarElement(data, pAvatar))
{
UpdateDataWithLocalOffsets(data, pState);
}
UpdateDataForTrigger(data, pState);
UpdateDataForSize(data, pState);
}
/*--------------------------------------------------------------------------------------------*/
private void BuildCursor(HoverCursorDataProvider pProv, ICursorData pData)
{
var curGo = new GameObject(pData.Type + "");
curGo.transform.SetParent(gameObject.transform, false);
TreeUpdater treeUp = curGo.AddComponent <TreeUpdater>();
HoverCursorFollower follow = curGo.AddComponent <HoverCursorFollower>();
follow.CursorDataProvider = pProv;
follow.CursorType = pData.Type;
follow.FollowCursorActive = false;
follow.ScaleUsingCursorSize = true;
HoverRendererCursorUpdater cursRendUp = curGo.AddComponent <HoverRendererCursorUpdater>();
cursRendUp.CursorRendererPrefab = CursorRendererPrefab;
if (pData.Idle != null)
{
HoverRendererIdleUpdater idleRendUp = curGo.AddComponent <HoverRendererIdleUpdater>();
idleRendUp.IdleRendererPrefab = IdleRendererPrefab;
}
follow.Update(); //moves interface to the correct cursor transform
treeUp.Update(); //force renderer creation
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake()
{
if (CursorDataProvider == null)
{
CursorDataProvider = FindObjectOfType <HoverCursorDataProvider>();
}
if (ProximityProvider == null)
{
ProximityProvider = GetComponent <HoverItemRendererUpdater>();
}
if (InteractionSettings == null)
{
InteractionSettings = (GetComponent <HoverInteractionSettings>() ??
FindObjectOfType <HoverItemsManager>().GetComponent <HoverInteractionSettings>());
}
if (CursorDataProvider == null)
{
Debug.LogWarning("Could not find 'CursorDataProvider'.");
}
if (ProximityProvider == null)
{
//TODO: show warning elsewhere? the renderer is typically added *after* this
//Debug.LogWarning("Could not find 'ProximityProvider'.");
}
if (InteractionSettings == null)
{
Debug.LogWarning("Could not find 'InteractionSettings'.");
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private ICursorDataForInput GetData(HoverCursorDataProvider pCursorDataProv)
{
if (!pCursorDataProv.HasCursorData(Type))
{
return(null);
}
return(pCursorDataProv.GetCursorDataForInput(Type));
}
public float ExtendFingertipDistance = 0; //TODO: test this
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake()
{
if (CursorDataProvider == null)
{
CursorDataProvider = FindObjectOfType <HoverCursorDataProvider>();
}
if (LeapServiceProvider == null)
{
LeapServiceProvider = FindObjectOfType <LeapServiceProvider>();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake()
{
if (CursorDataProvider == null)
{
CursorDataProvider = FindObjectOfType <HoverCursorDataProvider>();
}
if (LeapControl == null)
{
LeapControl = FindObjectOfType <HandController>();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake()
{
if (CursorDataProvider == null)
{
CursorDataProvider = FindObjectOfType <HoverCursorDataProvider>();
}
if (CursorDataProvider == null)
{
throw new ArgumentNullException("CursorDataProvider");
}
vHighStates = new List <HoverItemHighlightState>();
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void PerformBuild()
{
HoverCursorDataProvider cursorProv = FindObjectOfType <HoverCursorDataProvider>();
foreach (ICursorData cursorData in cursorProv.Cursors)
{
if (cursorData.Capability < MinimumCapabilityType)
{
continue;
}
BuildCursor(cursorProv, cursorData);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake()
{
if (CursorDataProvider == null)
{
CursorDataProvider = HoverCursorDataProvider.Instance;
}
if (CursorDataProvider == null)
{
throw new ArgumentNullException("CursorDataProvider");
}
vActiveHighStates = new List <HoverItemHighlightState>();
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake()
{
if (CursorDataProvider == null)
{
CursorDataProvider = HoverCursorDataProvider.Instance;
}
if (CursorDataProvider == null)
{
throw new ArgumentNullException("CursorDataProvider");
}
vItems = new List <HoverItem>();
vItemFilterFunc = FilterItems;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void UpdateData(HoverCursorDataProvider pCursorDataProv,
HoverInputVRTK.ControlState pState)
{
ICursorDataForInput data = GetData(pCursorDataProv);
if (data == null)
{
return;
}
data.SetUsedByInput(true);
UpdateDataWithLocalOffsets(data, pState);
UpdateDataForTrigger(data, pState);
UpdateDataForSize(data, pState);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Awake()
{
if (CursorDataProvider == null)
{
CursorDataProvider = FindObjectOfType <HoverCursorDataProvider>();
}
if (LookCursorTransform == null)
{
LookCursorTransform = Camera.main.transform;
}
if (SteamControllers == null)
{
SteamControllers = FindObjectOfType <SteamVR_ControllerManager>();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public override void OnInspectorGUI()
{
vTarget = (HoverCursorDataProvider)target;
DrawDefaultInspector();
EditorGUILayout.Separator();
DrawCursorList("Cursors", vTarget.Cursors);
if (vTarget.ExcludedCursors.Count == 0)
{
return;
}
EditorGUILayout.Separator();
EditorGUILayout.HelpBox("One or more duplicate cursor types were found. The following " +
"cursors have been excluded from the cursor list.", MessageType.Error);
DrawCursorList("Excluded Cursors", vTarget.ExcludedCursors);
}
/*--------------------------------------------------------------------------------------------*/
public void SwitchHands()
{
HoverCursorFollower follow = GetComponent <HoverCursorFollower>();
HoverCursorDataProvider curProv = follow.CursorDataProvider;
ICursorDataForInput stdFol = curProv.GetCursorDataForInput(StandardFollowCursor);
ICursorDataForInput swiFol = curProv.GetCursorDataForInput(SwitchedFollowCursor);
ICursorDataForInput stdInt = curProv.GetCursorDataForInput(StandardInteractionCursor);
ICursorDataForInput swiInt = curProv.GetCursorDataForInput(SwitchedInteractionCursor);
HovercastMirrorSwitcher mirror = GetComponent <HovercastMirrorSwitcher>();
bool isMirror = !mirror.UseMirrorLayout;
if (isMirror)
{
mirror.UseMirrorLayout = true;
follow.CursorType = SwitchedFollowCursor;
swiFol.SetCapability(CursorCapabilityType.TransformOnly);
swiInt.SetCapability(CursorCapabilityType.Full);
stdFol.SetCapability(CursorCapabilityType.None);
stdInt.SetCapability(CursorCapabilityType.None);
swiFol.gameObject.SetActive(true);
swiInt.gameObject.SetActive(true);
stdFol.gameObject.SetActive(false);
stdInt.gameObject.SetActive(false);
}
else
{
mirror.UseMirrorLayout = false;
follow.CursorType = StandardFollowCursor;
swiFol.SetCapability(CursorCapabilityType.None);
swiInt.SetCapability(CursorCapabilityType.None);
stdFol.SetCapability(CursorCapabilityType.TransformOnly);
stdInt.SetCapability(CursorCapabilityType.Full);
swiFol.gameObject.SetActive(false);
swiInt.gameObject.SetActive(false);
stdFol.gameObject.SetActive(true);
stdInt.gameObject.SetActive(true);
}
}
/*--------------------------------------------------------------------------------------------*/
protected override void PerformAdjustments()
{
HoverCursorDataProvider cursProv = FindObjectOfType <HoverCursorDataProvider>();
ICursorDataForInput palL = cursProv.GetCursorDataForInput(CursorType.LeftPalm);
ICursorDataForInput indR = cursProv.GetCursorDataForInput(CursorType.RightIndex);
ICursorDataForInput look = cursProv.GetCursorDataForInput(CursorType.Look);
HovercastInterface cast = FindObjectOfType <HovercastInterface>();
HoverCursorFollower castFollow = cast.GetComponent <HoverCursorFollower>();
HoverCursorRendererUpdater[] cursorRendUps =
Resources.FindObjectsOfTypeAll <HoverCursorRendererUpdater>();
foreach (HoverCursorRendererUpdater rendUp in cursorRendUps)
{
CursorType ct = rendUp.GetComponent <HoverCursorFollower>().CursorType;
rendUp.gameObject.SetActive(ct != CursorType.LeftPalm && ct != CursorType.RightPalm);
}
foreach (ICursorData cursorData in cursProv.Cursors)
{
ICursorDataForInput cursorDataInp = cursProv.GetCursorDataForInput(cursorData.Type);
cursorDataInp.SetCapability(CursorCapabilityType.None);
}
palL.SetCapability(CursorCapabilityType.TransformOnly);
indR.SetCapability(CursorCapabilityType.Full);
look.SetCapability(CursorCapabilityType.TransformOnly);
cast.transform.GetChild(0).localPosition =
new Vector3(0, 0, 0.02f); //moves "TransformAdjuster"
castFollow.CursorType = palL.Type;
//for non-playing editor...
palL.SetWorldRotation(Quaternion.Euler(0, 160, 80)); //face the camera (for editor)
castFollow.Update(); //moves interface to the correct cursor transform
cast.GetComponent <TreeUpdater>().Update(); //forces entire interface to update
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void PerformBuild()
{
TreeUpdater treeUp = gameObject.AddComponent <TreeUpdater>();
HoverCursorFollower follow = gameObject.AddComponent <HoverCursorFollower>();
HovercastInterface inter = gameObject.AddComponent <HovercastInterface>();
////
var adjustGo = new GameObject("TransformAdjuster");
adjustGo.transform.SetParent(transform, false);
adjustGo.transform.localPosition = new Vector3(0, 0, 0.02f);
adjustGo.transform.localRotation = Quaternion.Euler(0, 180, 80);
var openItemGo = new GameObject("OpenItem");
openItemGo.transform.SetParent(adjustGo.transform, false);
openItemGo.transform.localPosition = new Vector3(0, -0.05f, 0);
var titleItemGo = new GameObject("TitleItem");
titleItemGo.transform.SetParent(adjustGo.transform, false);
var backItemGo = new GameObject("BackItem");
backItemGo.transform.SetParent(adjustGo.transform, false);
var rowContGo = new GameObject("Rows");
rowContGo.transform.SetParent(adjustGo.transform, false);
rowContGo.AddComponent <TreeUpdater>();
var row0Go = new GameObject("Root");
row0Go.transform.SetParent(rowContGo.transform, false);
////
BuildOpenItem(openItemGo);
BuildTitleItem(titleItemGo);
BuildBackItem(backItemGo);
BuildRow(row0Go, "Hovercast");
if (IncludeExampleRows)
{
BuildExampleRows(rowContGo, row0Go);
}
adjustGo.AddComponent <TreeUpdater>(); //after building items
////
follow.CursorType = (AttachToLeftHand ? CursorType.LeftPalm : CursorType.RightPalm);
follow.ObjectsToActivate = new[] { openItemGo, titleItemGo, backItemGo, rowContGo };
inter.RowContainer = rowContGo.transform;
inter.ActiveRow = row0Go.GetComponent <HoverLayoutArcRow>();
inter.OpenItem = openItemGo.GetComponent <HoverItemDataSelector>();
inter.TitleItem = titleItemGo.GetComponent <HoverItemDataText>();
inter.BackItem = backItemGo.GetComponent <HoverItemDataSelector>();
HovercastOpenTransitioner openTrans = gameObject.AddComponent <HovercastOpenTransitioner>();
HovercastRowTransitioner rowTrans = gameObject.AddComponent <HovercastRowTransitioner>();
rowTrans.RowEntryTransition = HovercastRowSwitchingInfo.RowEntryType.FromInside;
#if UNITY_EDITOR
UnityEditor.Events.UnityEventTools.AddPersistentListener(
inter.OnOpenToggledEvent, openTrans.OnOpenToggled);
UnityEditor.Events.UnityEventTools.AddPersistentListener(
inter.OnRowSwitchedEvent, rowTrans.OnRowSwitched);
#else
inter.OnOpenToggledEvent.AddListener(openTrans.OnOpenToggled);
inter.OnRowSwitchedEvent.AddListener(rowTrans.OnRowSwitched);
#endif
gameObject.AddComponent <HovercastHighlightPreventer>();
HovercastBackCursorTrigger backTrig = gameObject.AddComponent <HovercastBackCursorTrigger>();
backTrig.BackTriggerCursorType = follow.CursorType;
HovercastActiveDirection actDir = gameObject.AddComponent <HovercastActiveDirection>();
actDir.ChildForActivation = adjustGo;
HovercastMirrorSwitcher mirror = gameObject.AddComponent <HovercastMirrorSwitcher>();
mirror.UseMirrorLayout = !AttachToLeftHand;
gameObject.AddComponent <HovercastAlphaUpdater>();
if (AutoRotateHandToFaceCamera)
{
HoverCursorDataProvider curDataProv = FindObjectOfType <HoverCursorDataProvider>();
ICursorDataForInput curData = curDataProv.GetCursorDataForInput(follow.CursorType);
float addRotZ = 80 * (AttachToLeftHand ? 1 : -1);
actDir.TreeUpdate(); //forces search for the "facing" transform
curData.transform.LookAt(actDir.ActiveWhenFacingTransform, Vector3.up);
curData.transform.localRotation *= Quaternion.Euler(0, 0, addRotZ);
}
follow.Update(); //moves interface to the correct cursor transform
treeUp.Update(); //forces entire interface to update
}
