/*--------------------------------------------------------------------------------------------*/
private void BuildRowNavItem(GameObject pRowGo, string pId, string pLabel,
GameObject pNavToRowGo)
{
GameObject itemGo = BuildRowItem(pRowGo, pId, pLabel, HoverItem.HoverItemType.Selector);
HovercastInterface inter = gameObject.GetComponent <HovercastInterface>();
bool isBack = (pNavToRowGo == null);
HoverItemDataSelector data = itemGo.GetComponent <HoverItemDataSelector>();
data.Action = (isBack ? SelectorActionType.NavigateOut : SelectorActionType.NavigateIn);
#if UNITY_EDITOR
UnityEditor.Events.UnityEventTools.AddPersistentListener(
data.OnSelectedEvent, inter.OnRowSwitched);
#else
data.OnSelectedEvent.AddListener(inter.OnRowSwitched);
#endif
HovercastRowSwitchingInfo rowSwitch = itemGo.AddComponent <HovercastRowSwitchingInfo>();
rowSwitch.NavigateBack = isBack;
rowSwitch.NavigateToRow = (isBack ? null : pNavToRowGo.GetComponent <HoverLayoutArcRow>());
rowSwitch.RowEntryTransition = (isBack ?
HovercastRowSwitchingInfo.RowEntryType.FromInside :
HovercastRowSwitchingInfo.RowEntryType.FromOutside
);
if (!isBack)
{
HoverCanvas can = itemGo.GetComponentInChildren <HoverCanvas>();
can.Alignment = HoverCanvas.CanvasAlignmentType.TextLeftAndIconRight;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Start()
{
HovercastInterface cast = GetComponent <HovercastInterface>();
SetScale(cast.IsOpen ? 1 : 0);
UpdateIcons(cast);
}
/*--------------------------------------------------------------------------------------------*/
public void TreeUpdate()
{
HovercastInterface cast = GetComponent <HovercastInterface>();
UpdateTimedProgress();
UpdateTransition(cast);
UpdateIcons(cast);
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateRows()
{
HovercastInterface cast = GetComponent <HovercastInterface>();
bool hasPrevRow = (cast.PreviousRow != null);
bool isTransitionDone = (TransitionProgress >= 1);
float outerRadius = InnerRadius + RowThickness;
float scaleFactor = outerRadius / InnerRadius;
float activeScale = 1;
float prevScale = 1;
TransitionProgressCurved = 1 - Mathf.Pow(1 - TransitionProgress, TransitionExponent);
cast.ActiveRow.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
cast.ActiveRow.Controllers.Set(SettingsControllerMap.TransformLocalScale, this);
cast.ActiveRow.Controllers.Set(HoverLayoutArcRow.OuterRadiusName, this);
cast.ActiveRow.Controllers.Set(HoverLayoutArcRow.InnerRadiusName, this);
cast.ActiveRow.InnerRadius = InnerRadius;
cast.ActiveRow.OuterRadius = outerRadius;
cast.ActiveRow.gameObject.SetActive(true);
if (hasPrevRow)
{
cast.PreviousRow.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
cast.PreviousRow.Controllers.Set(SettingsControllerMap.TransformLocalScale, this);
cast.PreviousRow.Controllers.Set(HoverLayoutArcRow.OuterRadiusName, this);
cast.PreviousRow.Controllers.Set(HoverLayoutArcRow.InnerRadiusName, this);
cast.PreviousRow.InnerRadius = InnerRadius;
cast.PreviousRow.OuterRadius = outerRadius;
cast.PreviousRow.gameObject.SetActive(!isTransitionDone);
}
if (!isTransitionDone)
{
switch (RowEntryTransition)
{
case HovercastRowSwitchingInfo.RowEntryType.FromInside:
activeScale = Mathf.Lerp(1 / scaleFactor, 1, TransitionProgressCurved);
prevScale = Mathf.Lerp(1, scaleFactor, TransitionProgressCurved);
break;
case HovercastRowSwitchingInfo.RowEntryType.FromOutside:
activeScale = Mathf.Lerp(scaleFactor, 1, TransitionProgressCurved);
prevScale = Mathf.Lerp(1, 1 / scaleFactor, TransitionProgressCurved);
break;
}
}
cast.ActiveRow.transform.localScale = Vector3.one * activeScale;
if (hasPrevRow)
{
cast.PreviousRow.transform.localScale = Vector3.one * prevScale;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public override void TreeUpdate()
{
HovercastOpenTransitioner open = gameObject.GetComponent <HovercastOpenTransitioner>();
HovercastRowTransitioner row = gameObject.GetComponent <HovercastRowTransitioner>();
HovercastInterface cast = gameObject.GetComponent <HovercastInterface>();
bool preventHigh = (open.IsTransitionActive || row.IsTransitionActive);
UpdateItem(cast.OpenItem, row.IsTransitionActive);
UpdateItem(cast.BackItem, preventHigh);
UpdateItem(cast.TitleItem, preventHigh);
UpdateRow(cast.PreviousRow, preventHigh);
UpdateRow(cast.ActiveRow, preventHigh);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void Start()
{
HovercastInterface cast = GetComponent <HovercastInterface>();
foreach (Transform childTx in cast.RowContainer)
{
HoverLayoutArcRow row = childTx.GetComponent <HoverLayoutArcRow>();
if (row != null && row != cast.ActiveRow)
{
childTx.gameObject.SetActive(false);
}
}
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateIcons(HovercastInterface pCast)
{
HovercastOpenIcons icons = pCast.OpenItem.GetComponentInChildren <HovercastOpenIcons>();
if (icons.OpenIcon != null)
{
icons.OpenIcon.SetActive(!pCast.IsOpen);
}
if (icons.CloseIcon != null)
{
icons.CloseIcon.SetActive(pCast.IsOpen);
}
}
/*--------------------------------------------------------------------------------------------*/
public void TreeUpdate()
{
HovercastInterface cast = gameObject.GetComponent <HovercastInterface>();
if (!cast.BackItem.IsEnabled)
{
return;
}
ICursorData cursorData = cast.GetComponent <HoverCursorFollower>()
.CursorDataProvider.GetCursorData(BackTriggerCursorType);
float triggerStrength = cursorData.TriggerStrength;
UpdateTrigger(cast, triggerStrength);
UpdateOverrider(cast.BackItem, triggerStrength);
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateTrigger(HovercastInterface pCast, float pTriggerStrength)
{
if (vIsTriggered && pTriggerStrength < TriggerAgainThreshold)
{
vIsTriggered = false;
return;
}
if (vIsTriggered || pTriggerStrength < 1)
{
return;
}
pCast.NavigateBack();
vIsTriggered = true;
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateWithTransitions()
{
HovercastOpenTransitioner open = gameObject.GetComponent <HovercastOpenTransitioner>();
HovercastRowTransitioner row = gameObject.GetComponent <HovercastRowTransitioner>();
HovercastInterface cast = gameObject.GetComponent <HovercastInterface>();
float openProg = open.TransitionProgressCurved;
float openAlpha = (cast.IsOpen ? openProg : 1 - openProg);
float prevAlpha = openAlpha * (1 - row.TransitionProgressCurved);
float activeAlpha = openAlpha * row.TransitionProgressCurved;
FadeItem(cast.OpenItem, 1);
FadeItem(cast.BackItem, openAlpha);
FadeItem(cast.TitleItem, openAlpha);
FadeRow(cast.PreviousRow, prevAlpha);
FadeRow(cast.ActiveRow, activeAlpha);
}
/*--------------------------------------------------------------------------------------------*/
private void BuildBackItem(GameObject pItemGo)
{
HoverItemBuilder build = pItemGo.AddComponent <HoverItemBuilder>();
build.ItemType = HoverItem.HoverItemType.Selector;
build.ButtonRendererPrefab = ButtonRendererPrefab;
build.OnEditorTriggerButtonSelected();
DestroyImmediate(build, false);
////
HovercastInterface inter = gameObject.GetComponent <HovercastInterface>();
HoverItemDataSelector data = pItemGo.GetComponent <HoverItemDataSelector>();
data.Id = "HovercastBackItem";
data.Label = "";
data.Action = SelectorActionType.NavigateOut;
#if UNITY_EDITOR
UnityEditor.Events.UnityEventTools.AddPersistentListener(
data.OnSelectedEvent, inter.OnRowSwitched);
#else
data.OnSelectedEvent.AddListener(inter.OnRowSwitched);
#endif
HoverFillButtonArcUpdater fillArcUp =
pItemGo.GetComponentInChildren <HoverFillButtonArcUpdater>();
fillArcUp.EdgePosition = HoverFillButtonArcUpdater.EdgePositionType.Outer;
HoverCanvas can = pItemGo.GetComponentInChildren <HoverCanvas>();
can.Alignment = HoverCanvas.CanvasAlignmentType.Custom;
can.IconOuter.transform.localPosition = new Vector3(-40, 0, 0);
HoverShapeArc shapeArc = pItemGo.AddComponent <HoverShapeArc>();
shapeArc.OuterRadius = 0.015f;
shapeArc.InnerRadius = 0;
shapeArc.ArcDegrees = 360;
HovercastRowSwitchingInfo rowSwitch = pItemGo.AddComponent <HovercastRowSwitchingInfo>();
rowSwitch.NavigateBack = true;
rowSwitch.RowEntryTransition = HovercastRowSwitchingInfo.RowEntryType.FromInside;
pItemGo.AddComponent <HoverIndicatorOverrider>();
}
/*--------------------------------------------------------------------------------------------*/
public void TreeUpdate()
{
HovercastInterface cast = gameObject.GetComponent <HovercastInterface>();
HoverCursorFollower follow = cast.GetComponent <HoverCursorFollower>();
UpdateCursorType(follow);
if (cast.BackItem.IsEnabled)
{
ICursorData cursorData = follow.CursorDataProvider.GetCursorData(CursorType);
float triggerStrength = cursorData.TriggerStrength;
UpdateTrigger(cast, triggerStrength);
UpdateOverrider(cast.BackItem, triggerStrength);
}
Controllers.TryExpireControllers();
}
/*--------------------------------------------------------------------------------------------*/
private void PerformSwitch()
{
HovercastInterface cast = GetComponent <HovercastInterface>();
Transform adjustTx = cast.transform.GetChild(0);
Vector3 flipY = new Vector3(1, -1, 1);
Vector3 flipZ = new Vector3(1, 1, -1);
Quaternion spinRotZ = Quaternion.Euler(0, 0, 180);
////
adjustTx.localRotation = Quaternion.Euler(
Vector3.Scale(adjustTx.localRotation.eulerAngles, flipZ));
adjustTx.localScale = Vector3.Scale(adjustTx.localScale, flipY);
////
cast.BackItem.transform.localRotation *= spinRotZ;
cast.TitleItem.transform.localRotation *= spinRotZ;
cast.OpenItem.transform.localRotation *= spinRotZ;
cast.RowContainer.transform.localRotation *= spinRotZ;
cast.OpenItem.transform.localPosition =
Vector3.Scale(cast.OpenItem.transform.localPosition, flipY);
////
cast.GetComponentsInChildren(true, vHoverCanvases);
for (int i = 0; i < vHoverCanvases.Count; i++)
{
HoverCanvas can = vHoverCanvases[i];
can.UseMirrorLayout = !can.UseMirrorLayout;
#if UNITY_EDITOR
//force serialization of changes made outside of the renderer prefab
UnityEditor.EditorUtility.SetDirty(can);
#endif
}
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateDegree()
{
HovercastInterface cast = GetComponent <HovercastInterface>();
Vector3 castWorldDir = cast.transform.TransformDirection(LocalFacingDirection.normalized);
Vector3 castToTxWorldVec = (ActiveWhenFacingTransform.position - cast.transform.position);
Vector3 castToTxWorldDir = castToTxWorldVec.normalized;
float dotBetweenDirs = Vector3.Dot(castWorldDir, castToTxWorldDir);
if (dotBetweenDirs >= 1)
{
CurrentDegree = 0;
}
else
{
CurrentDegree = Mathf.Acos(dotBetweenDirs) / Mathf.PI * 180;
}
ChildForActivation.SetActive(CurrentDegree <= InactiveOutsideDegree);
//Vector3 castPos = cast.transform.position;
//Debug.DrawLine(castPos, castPos+castWorldDir, Color.red);
//Debug.DrawLine(castPos, castPos+castToTxWorldDir, Color.cyan);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
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
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateTransition(HovercastInterface pCast)
{
TransitionProgressCurved = 1 - Mathf.Pow(1 - TransitionProgress, TransitionExponent);
SetScale(pCast.IsOpen ? TransitionProgressCurved : 1 - TransitionProgressCurved);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void BuildOpenItem(GameObject pItemGo)
{
HoverItemBuilder build = pItemGo.AddComponent <HoverItemBuilder>();
build.ItemType = HoverItem.HoverItemType.Selector;
build.ButtonRendererPrefab = ButtonRendererPrefab;
build.PerformBuild();
////
HovercastInterface inter = gameObject.GetComponent <HovercastInterface>();
HoverItemDataSelector data = pItemGo.GetComponent <HoverItemDataSelector>();
data.Id = "HovercastOpenItem";
data.Label = "";
#if UNITY_EDITOR
UnityEditor.Events.UnityEventTools.AddPersistentListener(
data.OnSelectedEvent, inter.OnOpenToggled);
#else
data.OnSelectedEvent.AddListener(inter.OnRowSwitched);
#endif
HoverCanvas can = pItemGo.GetComponentInChildren <HoverCanvas>();
var iconPivotGo = new GameObject("IconPivot");
iconPivotGo.transform.SetParent(can.transform, false);
var iconOpenGo = new GameObject("IconOpen");
iconOpenGo.transform.SetParent(iconPivotGo.transform, false);
var iconCloseGo = new GameObject("IconClose");
iconCloseGo.transform.SetParent(iconPivotGo.transform, false);
RectTransform iconPivotRectTx = iconPivotGo.AddComponent <RectTransform>();
iconPivotRectTx.localPosition = new Vector3(-47.5f, 0, 0);
iconPivotRectTx.localScale = new Vector3(2.2f, 2.2f, 1);
iconPivotRectTx.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, 100);
iconPivotRectTx.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 100);
RectTransform iconOpenRectTx = iconOpenGo.AddComponent <RectTransform>();
iconOpenRectTx.localPosition = new Vector3(19, 0, 0);
iconOpenRectTx.localRotation = Quaternion.Euler(0, 0, -45);
iconOpenRectTx.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, 40);
iconOpenRectTx.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 40);
RectTransform iconCloseRectTx = iconCloseGo.AddComponent <RectTransform>();
iconCloseRectTx.localPosition = new Vector3(19, 0, 0);
iconCloseRectTx.localRotation = Quaternion.Euler(0, 0, -45);
iconCloseRectTx.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, 40);
iconCloseRectTx.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, 40);
RawImage openImage = iconOpenGo.AddComponent <RawImage>();
openImage.material = Resources.Load <Material>("Materials/HovercastIconsMaterial");
openImage.uvRect = new Rect(0.002f, 0.002f, 0.496f, 0.996f);
RawImage closeImage = iconCloseGo.AddComponent <RawImage>();
closeImage.material = openImage.material;
closeImage.uvRect = new Rect(0.502f, 0.002f, 0.496f, 0.996f);
////
HoverShapeArc shapeArc = pItemGo.AddComponent <HoverShapeArc>();
shapeArc.OuterRadius = 0.02f;
shapeArc.InnerRadius = 0;
shapeArc.ArcDegrees = 360;
HovercastOpenIcons icons = pItemGo.AddComponent <HovercastOpenIcons>();
icons.OpenIcon = iconOpenGo;
icons.CloseIcon = iconCloseGo;
}
