////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void UpdateLayoutWithFixedSize()
{
int itemCount = vChildItems.Count;
if (itemCount == 0)
{
return;
}
bool isRev = (Arrangement == ArrangementType.OuterToInner);
float relSumThickness = 0;
float paddedOuterRadius = OuterRadius - Padding.OuterRadius;
float paddedInnerRadius = InnerRadius + Padding.InnerRadius;
float availDeg = ArcDegrees - Padding.StartDegree - Padding.EndDegree;
float availThick = paddedOuterRadius - paddedInnerRadius - Padding.Between * (itemCount - 1);
float innerRadius = paddedInnerRadius;
float paddedStartDeg = StartingDegree + (Padding.StartDegree - Padding.EndDegree) / 2;
Vector2 anchorPos = RendererUtil.GetRelativeAnchorPosition(RectAnchor);
anchorPos.x *= (vRectSize == null ? OuterRadius * 2 : ((Vector2)vRectSize).x);
anchorPos.y *= (vRectSize == null ? OuterRadius * 2 : ((Vector2)vRectSize).y);
for (int i = 0; i < itemCount; i++)
{
HoverLayoutArcGroupChild item = vChildItems[i];
relSumThickness += item.RelativeThickness;
}
for (int i = 0; i < itemCount; i++)
{
int childI = (isRev ? itemCount - i - 1 : i);
HoverLayoutArcGroupChild item = vChildItems[childI];
ILayoutableArc elem = item.Elem;
float elemRelThick = availThick * item.RelativeThickness / relSumThickness;
float elemRelArcDeg = availDeg * item.RelativeArcDegrees;
float radiusOffset = elemRelThick * item.RelativeRadiusOffset;
float elemStartDeg = paddedStartDeg + elemRelArcDeg * item.RelativeStartDegreeOffset;
elem.SetArcLayout(
innerRadius + elemRelThick + radiusOffset,
innerRadius + radiusOffset,
elemRelArcDeg,
this
);
elem.Controllers.Set(SettingsControllerMap.TransformLocalPosition + ".x", this);
elem.Controllers.Set(SettingsControllerMap.TransformLocalPosition + ".y", this);
elem.Controllers.Set(SettingsControllerMap.TransformLocalRotation, this);
Vector3 localPos = elem.transform.localPosition;
localPos.x = anchorPos.x;
localPos.y = anchorPos.y;
elem.transform.localPosition = localPos;
elem.transform.localRotation = Quaternion.AngleAxis(elemStartDeg, Vector3.back);
innerRadius += elemRelThick + Padding.Between;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void UpdateRenderer(ICursorData pCursorData)
{
IdleRenderer.Controllers.Set(HoverRendererIdle.CenterPositionName, this);
IdleRenderer.Controllers.Set(HoverRendererIdle.DistanceThresholdName, this);
IdleRenderer.Controllers.Set(HoverRendererIdle.TimerProgressName, this);
IdleRenderer.Controllers.Set(HoverRendererIdle.IsRaycastName, this);
IdleRenderer.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
IdleRenderer.CenterOffset =
transform.InverseTransformPoint(pCursorData.Idle.WorldPosition);
IdleRenderer.DistanceThreshold = pCursorData.Idle.DistanceThreshold;
IdleRenderer.TimerProgress = pCursorData.Idle.Progress;
IdleRenderer.IsRaycast = pCursorData.IsRaycast;
RendererUtil.SetActiveWithUpdate(IdleRenderer.gameObject, pCursorData.Idle.IsActive);
/*Transform itemPointHold = IdleRenderer.Fill.ItemPointer.transform.parent;
* Transform cursPointHold = IdleRenderer.Fill.CursorPointer.transform.parent;
*
* Vector3 itemCenter = GetComponent<HoverRendererUpdater>()
* .ActiveRenderer.GetCenterWorldPosition();
* Vector3 itemCenterLocalPos = IdleRenderer.transform
* .InverseTransformPoint(itemCenter);
* Vector3 cursorLocalPos = IdleRenderer.transform
* .InverseTransformPoint(pCursorData.WorldPosition);
*
* itemPointHold.localRotation = Quaternion.FromToRotation(Vector3.right, itemCenterLocalPos);
* cursPointHold.localRotation = Quaternion.FromToRotation(Vector3.right, cursorLocalPos);*/
}
/*--------------------------------------------------------------------------------------------*/
protected override void ActivateFillMesh(HoverMesh pSegmentMesh)
{
HoverShapeRect meshShapeRect = pSegmentMesh.GetComponent <HoverShapeRect>();
pSegmentMesh.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
RendererUtil.SetActiveWithUpdate(pSegmentMesh, (meshShapeRect.SizeY > 0));
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateActiveStates()
{
bool isLabelActive = (!string.IsNullOrEmpty(Label.TextComponent.text));
bool isIconOuterActive = (IconOuter.IconType != HoverIcon.IconOffset.None);
bool isIconInnerActive = (IconInner.IconType != HoverIcon.IconOffset.None);
RendererUtil.SetActiveWithUpdate(Label, isLabelActive);
RendererUtil.SetActiveWithUpdate(IconOuter, isIconOuterActive);
RendererUtil.SetActiveWithUpdate(IconInner, isIconInnerActive);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void UpdateTickList()
{
if (SegmentInfo == null || SegmentInfo.TickInfoList == null)
{
return;
}
int newTickCount = SegmentInfo.TickInfoList.Count;
if (Ticks.Count == newTickCount)
{
return;
}
#if UNITY_EDITOR
//ticks are often added within a prefab; this forces serialization of the "Ticks" list
UnityEditor.EditorUtility.SetDirty(this);
#endif
if (TickPrefab == null)
{
Debug.LogWarning("Cannot build ticks without a prefab reference.", this);
return;
}
while (Ticks.Count < newTickCount)
{
HoverMesh tickMesh = RendererUtil.TryBuildPrefabRenderer <HoverMesh>(TickPrefab);
tickMesh.name = "Tick" + Ticks.Count;
tickMesh.transform.SetParent(gameObject.transform, false);
Ticks.Add(tickMesh);
}
while (Ticks.Count > newTickCount)
{
int lastTickIndex = Ticks.Count - 1;
HoverMesh tick = Ticks[lastTickIndex];
Ticks.RemoveAt(lastTickIndex);
if (Application.isPlaying)
{
Destroy(tick.gameObject);
}
else
{
tick.gameObject.SetActive(false);
tick.GetComponent <TreeUpdater>().enabled = false;
DestroyImmediate(tick.gameObject);
}
}
GetComponent <TreeUpdater>().ImmediateReloadTreeChildren();
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void DestroyRendererIfNecessary()
{
if (ClickToRebuildRenderer || CursorRendererPrefab != vPrevCursorPrefab)
{
vPrevCursorPrefab = CursorRendererPrefab;
RendererUtil.DestroyRenderer(CursorRenderer);
CursorRenderer = null;
}
ClickToRebuildRenderer = false;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void DestroyRendererIfNecessary()
{
if (ClickToRebuildRenderer || IdleRendererPrefab != vPrevIdlePrefab)
{
vPrevIdlePrefab = IdleRendererPrefab;
RendererUtil.DestroyRenderer(IdleRenderer);
IdleRenderer = null;
}
ClickToRebuildRenderer = false;
}
/*--------------------------------------------------------------------------------------------*/
protected virtual void UpdateMeshShape(HoverMesh pMesh, float pOuterRad, float pInnerRad,
bool pShowMesh = true)
{
HoverShapeArc meshShape = pMesh.GetComponent <HoverShapeArc>();
pMesh.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
meshShape.Controllers.Set(HoverShapeArc.OuterRadiusName, this);
meshShape.Controllers.Set(HoverShapeArc.InnerRadiusName, this);
RendererUtil.SetActiveWithUpdate(pMesh, (pShowMesh && pMesh.IsMeshVisible));
meshShape.OuterRadius = pOuterRad;
meshShape.InnerRadius = pInnerRad;
}
/*--------------------------------------------------------------------------------------------*/
protected virtual void UpdateMeshShape(HoverMesh pMesh, float pSizeX, float pSizeY,
bool pShowMesh = true)
{
HoverShapeRect meshShape = pMesh.GetComponent <HoverShapeRect>();
pMesh.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
meshShape.Controllers.Set(HoverShapeRect.SizeXName, this);
meshShape.Controllers.Set(HoverShapeRect.SizeYName, this);
RendererUtil.SetActiveWithUpdate(pMesh, (pShowMesh && pMesh.IsMeshVisible));
meshShape.SizeX = pSizeX;
meshShape.SizeY = pSizeY;
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateActiveStates()
{
bool isLabelActive = (!string.IsNullOrEmpty(Label.TextComponent.text));
bool isIconOuterActive = (IconOuter.IconType != HoverIcon.IconOffset.None);
bool isIconInnerActive = (IconInner.IconType != HoverIcon.IconOffset.None);
Label.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
IconOuter.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
IconInner.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
RendererUtil.SetActiveWithUpdate(Label, isLabelActive);
RendererUtil.SetActiveWithUpdate(IconOuter, isIconOuterActive);
RendererUtil.SetActiveWithUpdate(IconInner, isIconInnerActive);
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateButtons()
{
HoverRendererSliderSegments segs = gameObject.GetComponent <HoverRendererSliderSegments>();
HandleButton.Controllers.Set(HoverRendererButton.IsEnabledName, this);
JumpButton.Controllers.Set(HoverRendererButton.IsEnabledName, this);
HandleButton.Fill.Controllers.Set(HoverFillButton.ShowEdgeName, this);
JumpButton.Fill.Controllers.Set(HoverFillButton.ShowEdgeName, this);
HandleButton.IsEnabled = IsEnabled;
JumpButton.IsEnabled = IsEnabled;
HandleButton.Fill.ShowEdge = ShowButtonEdges;
JumpButton.Fill.ShowEdge = ShowButtonEdges;
RendererUtil.SetActiveWithUpdate(JumpButton, (AllowJump && segs.IsJumpVisible));
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateRenderer(HoverCursorFollower pFollower)
{
ICursorData cursorData = pFollower.GetCursorData();
HoverIndicator cursorInd = CursorRenderer.GetIndicator();
CursorRenderer.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
CursorRenderer.Controllers.Set(HoverRendererCursor.IsRaycastName, this);
CursorRenderer.Controllers.Set(HoverRendererCursor.RaycastWorldOriginName, this);
cursorInd.Controllers.Set(HoverIndicator.HighlightProgressName, this);
cursorInd.Controllers.Set(HoverIndicator.SelectionProgressName, this);
RendererUtil.SetActiveWithUpdate(CursorRenderer, cursorData.IsActive);
CursorRenderer.IsRaycast = cursorData.IsRaycast;
CursorRenderer.RaycastWorldOrigin = cursorData.WorldPosition;
cursorInd.HighlightProgress = cursorData.MaxItemHighlightProgress;
cursorInd.SelectionProgress = cursorData.MaxItemSelectionProgress;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public override void TreeUpdate()
{
base.TreeUpdate();
vWorldPlane = RendererUtil.GetWorldPlane(gameObject.transform);
DidSettingsChange = (
DidSettingsChange ||
SizeX != vPrevSizeX ||
SizeY != vPrevSizeY
);
UpdateShapeRectChildren();
vPrevSizeX = SizeX;
vPrevSizeY = SizeY;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void DestroyRenderersIfNecessary()
{
if (ClickToRebuildRenderer || ButtonRendererPrefab != vPrevButtonPrefab)
{
vPrevButtonPrefab = ButtonRendererPrefab;
RendererUtil.DestroyRenderer(ButtonRenderer);
ButtonRenderer = null;
}
if (ClickToRebuildRenderer || SliderRendererPrefab != vPrevSliderPrefab)
{
vPrevSliderPrefab = SliderRendererPrefab;
RendererUtil.DestroyRenderer(SliderRenderer);
SliderRenderer = null;
}
ClickToRebuildRenderer = false;
}
/*--------------------------------------------------------------------------------------------*/
public override Vector3 GetNearestWorldPosition(Ray pFromWorldRay, out RaycastResult pRaycast)
{
pRaycast = new RaycastResult();
Vector3?nearWorldPos =
RendererUtil.GetNearestWorldPositionOnPlane(pFromWorldRay, vWorldPlane);
if (nearWorldPos == null)
{
return(pFromWorldRay.origin);
}
pRaycast.IsHit = true;
pRaycast.WorldPosition = nearWorldPos.Value;
pRaycast.WorldRotation = transform.rotation;
pRaycast.WorldPlane = vWorldPlane;
return(GetNearestWorldPosition(pRaycast.WorldPosition));
}
/*--------------------------------------------------------------------------------------------*/
protected override void UpdateTickMesh(HoverMesh pTickMesh, SliderUtil.SegmentInfo pTickInfo)
{
HoverShapeArc meshShapeArc = pTickMesh.GetComponent <HoverShapeArc>();
pTickMesh.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
pTickMesh.Controllers.Set(SettingsControllerMap.TransformLocalRotation, this);
meshShapeArc.Controllers.Set(HoverShapeArc.OuterRadiusName, this);
meshShapeArc.Controllers.Set(HoverShapeArc.InnerRadiusName, this);
meshShapeArc.Controllers.Set(HoverShapeArc.ArcDegreesName, this);
meshShapeArc.OuterRadius = vTickOuterRadius;
meshShapeArc.InnerRadius = vTickInnerRadius;
meshShapeArc.ArcDegrees = pTickInfo.EndPosition - pTickInfo.StartPosition;
pTickMesh.transform.localRotation = Quaternion.AngleAxis(
(pTickInfo.StartPosition + pTickInfo.EndPosition) / 2, Vector3.forward);
RendererUtil.SetActiveWithUpdate(pTickMesh, !pTickInfo.IsHidden);
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateRenderer(HoverCursorFollower pFollower)
{
ICursorData cursorData = pFollower.GetCursorData();
HoverIndicator cursorInd = CursorRenderer.GetIndicator();
CursorRenderer.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
CursorRenderer.Controllers.Set(HoverRendererCursor.IsRaycastName, this);
CursorRenderer.Controllers.Set(HoverRendererCursor.ShowRaycastLineName, this);
CursorRenderer.Controllers.Set(HoverRendererCursor.RaycastWorldOriginName, this);
cursorInd.Controllers.Set(HoverIndicator.HighlightProgressName, this);
cursorInd.Controllers.Set(HoverIndicator.SelectionProgressName, this);
RendererUtil.SetActiveWithUpdate(CursorRenderer,
(cursorData.IsActive && cursorData.Capability != CursorCapabilityType.None));
CursorRenderer.IsRaycast = cursorData.IsRaycast;
CursorRenderer.ShowRaycastLine = (cursorData.CanCauseSelections &&
cursorData.Type != CursorType.Look);
CursorRenderer.RaycastWorldOrigin = cursorData.WorldPosition;
cursorInd.HighlightProgress = cursorData.MaxItemHighlightProgress;
cursorInd.SelectionProgress = cursorData.MaxItemSelectionProgress;
}
/*--------------------------------------------------------------------------------------------*/
protected override void UpdateTickMesh(HoverMesh pTickMesh, SliderUtil.SegmentInfo pTickInfo)
{
HoverShapeRect meshShapeRect = pTickMesh.GetComponent <HoverShapeRect>();
pTickMesh.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
pTickMesh.Controllers.Set(SettingsControllerMap.TransformLocalPosition + ".x", this);
pTickMesh.Controllers.Set(SettingsControllerMap.TransformLocalPosition + ".y", this);
meshShapeRect.Controllers.Set(HoverShapeRect.SizeXName, this);
meshShapeRect.Controllers.Set(HoverShapeRect.SizeYName, this);
meshShapeRect.SizeX = vTickSizeX;
meshShapeRect.SizeY = pTickInfo.EndPosition - pTickInfo.StartPosition;
Vector3 localPos = pTickMesh.transform.localPosition;
localPos.x = (InsetLeft - InsetRight) / 2;
localPos.y = (pTickInfo.StartPosition + pTickInfo.EndPosition) / 2;
pTickMesh.transform.localPosition = localPos;
RendererUtil.SetActiveWithUpdate(pTickMesh, !pTickInfo.IsHidden);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void UpdatePosition()
{
if (RaycastLine != null)
{
RaycastLine.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
RaycastLine.Controllers.Set(HoverRaycastLine.RaycastWorldOriginName, this);
RaycastLine.RaycastWorldOrigin = RaycastWorldOrigin;
RendererUtil.SetActiveWithUpdate(RaycastLine, (IsRaycast && ShowRaycastLine));
}
if (!Application.isPlaying || !IsRaycast)
{
return;
}
Controllers.Set(SettingsControllerMap.TransformLocalPosition + ".z", this);
Vector3 localPos = transform.localPosition;
localPos.z = RaycastOffsetZ / transform.lossyScale.z;
transform.localPosition = localPos;
}
/*--------------------------------------------------------------------------------------------*/
private void TryRebuildWithItemType(HoverItem.HoverItemType pType)
{
if (pType == HoverItem.HoverItemType.Slider)
{
Controllers.Set(ButtonRendererName, this);
Controllers.Unset(SliderRendererName, this);
RendererUtil.DestroyRenderer(ButtonRenderer);
ButtonRenderer = null;
SliderRenderer = (SliderRenderer ?? FindOrBuildSlider());
IsButtonRendererType = false;
}
else
{
Controllers.Set(SliderRendererName, this);
Controllers.Unset(ButtonRendererName, this);
RendererUtil.DestroyRenderer(SliderRenderer);
SliderRenderer = null;
ButtonRenderer = (ButtonRenderer ?? FindOrBuildButton());
IsButtonRendererType = true;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public override void TreeUpdate()
{
base.TreeUpdate();
vWorldPlane = RendererUtil.GetWorldPlane(gameObject.transform);
DidSettingsChange = (
DidSettingsChange ||
OuterRadius != vPrevOuterRad ||
InnerRadius != vPrevInnerRad ||
ArcDegrees != vPrevDegrees ||
OuterOffset != vPrevOuterOff ||
InnerOffset != vPrevInnerOff
);
UpdateShapeArcChildren();
vPrevOuterRad = OuterRadius;
vPrevInnerRad = InnerRadius;
vPrevDegrees = ArcDegrees;
vPrevOuterOff = OuterOffset;
vPrevInnerOff = InnerOffset;
}
/*--------------------------------------------------------------------------------------------*/
public void TreeUpdate()
{
bool isSelected = (
!UseItemSelectionState ||
CanvasUpdater.IconType == HoverCanvasDataUpdater.IconPairType.RadioOn ||
CanvasUpdater.IconType == HoverCanvasDataUpdater.IconPairType.CheckboxOn
);
HoverMesh.DisplayModeType dispMode = (isSelected ?
HoverMesh.DisplayModeType.SliderFill : HoverMesh.DisplayModeType.Standard);
////
HoverShapeRect shapeRect = GetComponent <HoverShapeRect>();
float minOutward = -Mathf.Min(shapeRect.SizeX, shapeRect.SizeY) / 2;
TabOutward = Mathf.Max(TabOutward, minOutward);
TabThickness = Mathf.Max(TabThickness, 0);
////
HoverFillButton hoverFill = GetComponent <HoverFillButton>();
int meshCount = hoverFill.GetChildMeshCount();
for (int i = 0; i < meshCount; i++)
{
UpdateChildMesh((HoverMeshRectHollowTab)hoverFill.GetChildMesh(i), dispMode);
}
if (isSelected)
{
hoverFill.Controllers.Set(HoverFillButton.ShowEdgeName, this);
hoverFill.ShowEdge = true;
RendererUtil.SetActiveWithUpdate(hoverFill.Edge, true);
}
}
/*--------------------------------------------------------------------------------------------*/
private HoverRendererIdle FindOrBuildIdle()
{
return(RendererUtil.FindOrBuildRenderer <HoverRendererIdle>(gameObject.transform,
IdleRendererPrefab, "Idle", typeof(HoverRendererIdle)));
}
/*--------------------------------------------------------------------------------------------*/
private HoverRendererCursor FindOrBuildCursor()
{
return(RendererUtil.FindOrBuildRenderer <HoverRendererCursor>(gameObject.transform,
CursorRendererPrefab, "Cursor", typeof(HoverRendererCursor)));
}
/*--------------------------------------------------------------------------------------------*/
private HoverRendererSlider FindOrBuildSlider()
{
return(RendererUtil.FindOrBuildRenderer <HoverRendererSlider>(gameObject.transform,
SliderRendererPrefab, "Slider", typeof(HoverRendererSlider)));
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateMesh(HoverMesh pMesh)
{
pMesh.Controllers.Set(SettingsControllerMap.GameObjectActiveSelf, this);
RendererUtil.SetActiveWithUpdate(pMesh, pMesh.IsMeshVisible);
}
/*--------------------------------------------------------------------------------------------*/
public override Vector3 GetNearestWorldPosition(Vector3 pFromWorldPosition)
{
return(RendererUtil.GetNearestWorldPositionOnArc(pFromWorldPosition,
gameObject.transform, OuterRadius, InnerRadius, ArcDegrees));
}
/*--------------------------------------------------------------------------------------------*/
private HoverRendererButton FindOrBuildButton()
{
return(RendererUtil.FindOrBuildRenderer <HoverRendererButton>(gameObject.transform,
ButtonRendererPrefab, "Button", typeof(HoverRendererButton)));
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateLayoutWithFixedSize()
{
int itemCount = vChildItems.Count;
if (itemCount == 0)
{
return;
}
bool isHoriz = IsHorizontal;
bool isRev = IsReversed;
Vector2 anchorPos = RendererUtil.GetRelativeAnchorPosition(Anchor);
float anchorStartX = anchorPos.x * SizeX;
float anchorStartY = anchorPos.y * SizeY;
float horizOuterPad = Padding.Left + Padding.Right;
float vertOuterPad = Padding.Top + Padding.Bottom;
float betweenSumPad = Padding.Between * (itemCount - 1);
float relSumX = 0;
float relSumY = 0;
float elemAvailSizeX;
float elemAvailSizeY;
float cellAvailSizeX;
float cellAvailSizeY;
if (isHoriz)
{
elemAvailSizeX = SizeX - horizOuterPad - betweenSumPad;
elemAvailSizeY = SizeY - vertOuterPad;
cellAvailSizeX = SizeX - horizOuterPad;
cellAvailSizeY = elemAvailSizeY;
}
else
{
elemAvailSizeX = SizeX - horizOuterPad;
elemAvailSizeY = SizeY - vertOuterPad - betweenSumPad;
cellAvailSizeX = elemAvailSizeX;
cellAvailSizeY = SizeY - vertOuterPad;
}
for (int i = 0; i < itemCount; i++)
{
HoverLayoutRectGroupChild item = vChildItems[i];
relSumX += item.RelativeSizeX;
relSumY += item.RelativeSizeY;
}
float posX = anchorStartX - (Padding.Right - Padding.Left) / 2 -
(isHoriz ? cellAvailSizeX / 2 : 0);
float posY = anchorStartY - (Padding.Top - Padding.Bottom) / 2 -
(isHoriz ? 0 : cellAvailSizeY / 2);
for (int i = 0; i < itemCount; i++)
{
int childI = (isRev ? itemCount - i - 1 : i);
HoverLayoutRectGroupChild item = vChildItems[childI];
ILayoutableRect elem = item.Elem;
Vector3 localPos = elem.transform.localPosition;
float elemRelSizeX = elemAvailSizeX * item.RelativeSizeX / (isHoriz ? relSumX : 1);
float elemRelSizeY = elemAvailSizeY * item.RelativeSizeY / (isHoriz ? 1 : relSumY);
localPos.x = posX + (isHoriz ? elemRelSizeX / 2 : 0) +
elemRelSizeX * item.RelativePositionOffsetX;
localPos.y = posY + (isHoriz ? 0 : elemRelSizeY / 2) +
elemRelSizeY * item.RelativePositionOffsetY;
posX += (isHoriz ? elemRelSizeX + Padding.Between : 0);
posY += (isHoriz ? 0 : elemRelSizeY + Padding.Between);
elem.Controllers.Set(
SettingsControllerMap.SpecialPrefix + "Transform.localPosition.x", this);
elem.Controllers.Set(
SettingsControllerMap.SpecialPrefix + "Transform.localPosition.y", this);
elem.SetRectLayout(elemRelSizeX, elemRelSizeY, this);
elem.transform.localPosition = localPos;
}
}
/*--------------------------------------------------------------------------------------------*/
public override Vector3 GetNearestWorldPosition(Vector3 pFromWorldPosition)
{
return(RendererUtil.GetNearestWorldPositionOnRectangle(
pFromWorldPosition, gameObject.transform, SizeX, SizeY));
}
