private void ProcessOneChild(RectTransform child, float angle, float radius)
{
Vector3 pos = new Vector3(
Mathf.Cos(angle * Mathf.Deg2Rad),
Mathf.Sin(angle * Mathf.Deg2Rad),
0.0f);
child.localPosition = pos * radius;
DrivenTransformProperties drivenProperties =
DrivenTransformProperties.Anchors | DrivenTransformProperties.AnchoredPosition | DrivenTransformProperties.Rotation | DrivenTransformProperties.Pivot;
m_Tracker.Add(this, child, drivenProperties);
child.anchorMin = center;
child.anchorMax = center;
child.pivot = center;
if (this.ChildRotate)
{
child.localEulerAngles = new Vector3(0, 0, angle);
}
else
{
child.localEulerAngles = Vector3.zero;
}
}
/// <summary>
/// <para>Add a RectTransform to be driven.</para>
/// </summary>
/// <param name="driver">The object to drive properties.</param>
/// <param name="rectTransform">The RectTransform to be driven.</param>
/// <param name="drivenProperties">The properties to be driven.</param>
public void Add(Object driver, RectTransform rectTransform, DrivenTransformProperties drivenProperties)
{
if (this.m_Tracked == null)
this.m_Tracked = new List<RectTransform>();
rectTransform.drivenByObject = driver;
rectTransform.drivenProperties = rectTransform.drivenProperties | drivenProperties;
if (!Application.isPlaying)
RuntimeUndo.RecordObject((Object) rectTransform, "Driving RectTransform");
this.m_Tracked.Add(rectTransform);
}
public void Add(UnityEngine.Object driver, RectTransform rectTransform, DrivenTransformProperties drivenProperties)
{
if (this.m_Tracked == null)
{
this.m_Tracked = new List<RectTransform>();
}
if (!Application.isPlaying)
{
RuntimeUndo.RecordObject(rectTransform, "Driving RectTransform");
}
this.m_Tracked.Add(rectTransform);
rectTransform.drivenByObject = driver;
rectTransform.drivenProperties |= drivenProperties;
}
private void HandleSelfFittingAlongAxis(int axis)
{
FitMode fitting = (axis == 0 ? horizontalFit : verticalFit);
if (fitting == FitMode.Unconstrained)
{
// Keep a reference to the tracked transform, but don't control its properties:
m_Tracker.Add(this, rectTsfm, DrivenTransformProperties.None);
return;
}
DrivenTransformProperties flags = DrivenTransformProperties.ScaleX | DrivenTransformProperties.ScaleY;
if (horizontalFit != FitMode.Unconstrained)
{
flags |= DrivenTransformProperties.SizeDeltaX;
}
if (verticalFit != FitMode.Unconstrained)
{
flags |= DrivenTransformProperties.SizeDeltaY;
}
m_Tracker.Add(this, rectTsfm, flags);
// Set size to min or preferred size
float newSize = 0f;
if (fitting == FitMode.MinSize)
{
newSize = LayoutUtility.GetMinSize(m_Rect, axis);
newSize = axis == 0 ? Mathf.Max(newSize, m_fixedSize.x) : Mathf.Max(newSize, m_fixedSize.y);
}
else
{
newSize = LayoutUtility.GetPreferredSize(m_Rect, axis);
}
Vector2 newSizeV;
if (axis == 0)
{
newSizeV = new Vector2(Mathf.Max(newSize, m_fixedSize.x), m_Rect.sizeDelta.y);
}
else
{
newSizeV = new Vector2(m_Rect.sizeDelta.x, Mathf.Max(newSize, m_fixedSize.y));
}
m_Rect.SetSizeWithCurrentAnchors((RectTransform.Axis)axis, newSize);
m_Rect.localScale = CalculateSizeScale(newSizeV, axis);
}
public void Add(Object driver, RectTransform rectTransform, DrivenTransformProperties drivenProperties)
{
if (this.m_Tracked == null)
{
this.m_Tracked = new List <RectTransform>();
}
rectTransform.drivenByObject = driver;
rectTransform.drivenProperties |= drivenProperties;
if (!Application.isPlaying && DrivenRectTransformTracker.CanRecordModifications())
{
RuntimeUndo.RecordObject(rectTransform, "Driving RectTransform");
}
this.m_Tracked.Add(rectTransform);
}
public void Add(UnityEngine.Object driver, RectTransform rectTransform, DrivenTransformProperties drivenProperties)
{
if (this.m_Tracked == null)
{
this.m_Tracked = new List <RectTransform>();
}
if (!Application.isPlaying)
{
RuntimeUndo.RecordObject(rectTransform, "Driving RectTransform");
}
this.m_Tracked.Add(rectTransform);
rectTransform.drivenByObject = driver;
rectTransform.drivenProperties |= drivenProperties;
}
void Add2Tracker(RectTransform child)
{
DrivenTransformProperties driven_properties = DrivenTransformProperties.None;
if (ChildrenWidth != ChildrenSize.DoNothing)
{
driven_properties |= DrivenTransformProperties.SizeDeltaX;
}
if (ChildrenHeight != ChildrenSize.DoNothing)
{
driven_properties |= DrivenTransformProperties.SizeDeltaY;
}
propertiesTracker.Add(this, child, driven_properties);
}
protected virtual float AlignChild(RectTransform child, ref float offset)
{
float num = (this.direction != AlignDirection.LeftToRight) ? ((float)(-1)) : ((float)1);
float num2 = (this.direction != AlignDirection.LeftToRight) ? ((float)1) : ((float)0);
DrivenTransformProperties properties = 0x502;
this.tracker.Add(this, child, properties);
child.set_anchorMin(new Vector2(num2, child.get_anchorMin().y));
child.set_anchorMax(new Vector2(num2, child.get_anchorMax().y));
this.CustomChild(child, offset);
float num3 = child.get_rect().get_width() * Mathf.Abs(child.get_localScale().x);
offset += num * (num3 * child.get_pivot().x);
child.set_anchoredPosition(new Vector2(offset, child.get_anchoredPosition().y));
offset += num * ((num3 * (1f - child.get_pivot().x)) + base.space);
return(num3);
}
public void Add(Object driver, RectTransform rectTransform, DrivenTransformProperties drivenProperties)
{
if (m_Tracked == null)
{
m_Tracked = new List <RectTransform>();
}
if (!Application.isPlaying && CanRecordModifications() && !s_BlockUndo)
{
RuntimeUndo.RecordObject(rectTransform, "Driving RectTransform");
}
rectTransform.drivenByObject = driver;
rectTransform.drivenProperties = rectTransform.drivenProperties | drivenProperties;
m_Tracked.Add(rectTransform);
}
public void Add(Object driver, RectTransform rectTransform, DrivenTransformProperties drivenProperties)
{
bool flag = this.m_Tracked == null;
if (flag)
{
this.m_Tracked = new List <RectTransform>();
}
bool flag2 = !Application.isPlaying && DrivenRectTransformTracker.CanRecordModifications() && !DrivenRectTransformTracker.s_BlockUndo;
if (flag2)
{
RuntimeUndo.RecordObject(rectTransform, "Driving RectTransform");
}
rectTransform.drivenByObject = driver;
rectTransform.drivenProperties |= drivenProperties;
this.m_Tracked.Add(rectTransform);
}
void ResizeChild(RectTransform child)
{
DrivenTransformProperties driven_properties = DrivenTransformProperties.None;
if (ChildrenWidth != ChildrenSize.DoNothing)
{
driven_properties |= DrivenTransformProperties.SizeDeltaX;
var width = (max_width != -1) ? max_width : GetPreferredWidth(child);
child.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, width);
}
if (ChildrenHeight != ChildrenSize.DoNothing)
{
driven_properties |= DrivenTransformProperties.SizeDeltaY;
var height = (max_height != -1) ? max_height : GetPreferredHeight(child);
child.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, height);
}
propertiesTracker.Add(this, child, driven_properties);
}
protected override void CustomLayoutRectTransform()
{
DrivenTransformProperties properties = 0;
properties |= 0x4500;
this.tracker.Add(this, base.CachedRectTransform, properties);
if (base.direction == UguiHorizontalAlignGroup.AlignDirection.LeftToRight)
{
base.CachedRectTransform.set_anchorMin(new Vector2(0f, base.CachedRectTransform.get_anchorMin().y));
base.CachedRectTransform.set_anchorMax(new Vector2(0f, base.CachedRectTransform.get_anchorMax().y));
base.CachedRectTransform.set_pivot(new Vector2(0f, base.CachedRectTransform.get_pivot().y));
}
else
{
base.CachedRectTransform.set_anchorMin(new Vector2(1f, base.CachedRectTransform.get_anchorMin().y));
base.CachedRectTransform.set_anchorMax(new Vector2(1f, base.CachedRectTransform.get_anchorMax().y));
base.CachedRectTransform.set_pivot(new Vector2(1f, base.CachedRectTransform.get_pivot().y));
}
}
protected override void CustomLayoutRectTransform()
{
DrivenTransformProperties properties = 0;
properties |= 0x8a00;
this.tracker.Add(this, base.CachedRectTransform, properties);
if (base.direction == UguiVerticalAlignGroup.AlignDirection.BottomToTop)
{
base.CachedRectTransform.set_anchorMin(new Vector2(base.CachedRectTransform.get_anchorMin().x, 0f));
base.CachedRectTransform.set_anchorMax(new Vector2(base.CachedRectTransform.get_anchorMax().x, 0f));
base.CachedRectTransform.set_pivot(new Vector2(base.CachedRectTransform.get_pivot().x, 0f));
}
else
{
base.CachedRectTransform.set_anchorMin(new Vector2(base.CachedRectTransform.get_anchorMin().x, 1f));
base.CachedRectTransform.set_anchorMax(new Vector2(base.CachedRectTransform.get_anchorMax().x, 1f));
base.CachedRectTransform.set_pivot(new Vector2(base.CachedRectTransform.get_pivot().x, 1f));
}
}
/// <summary>
/// Actual resize.
/// </summary>
public void ApplyResize()
{
DrivenTransformProperties driven_properties = DrivenTransformProperties.AnchoredPosition | DrivenTransformProperties.AnchoredPositionZ;
if (ChangedWidth)
{
driven_properties |= DrivenTransformProperties.SizeDeltaX;
Rect.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, NewWidth);
}
if (ChangedHeight)
{
driven_properties |= DrivenTransformProperties.SizeDeltaY;
Rect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, NewHeight);
}
if (ChangedWidth || ChangedHeight)
{
Resizer.PropertiesTracker.Add(Layout, Rect, driven_properties);
}
}
protected DrivenTransformProperties GetChildPropertyDriven(int axis, bool wheelEffect)
{
DrivenTransformProperties driven = DrivenTransformProperties.AnchoredPosition3D | DrivenTransformProperties.Rotation;
if (axis == 0)
{
driven |= DrivenTransformProperties.AnchorMinX | DrivenTransformProperties.AnchorMaxX;
}
else
{
driven |= DrivenTransformProperties.AnchorMinY | DrivenTransformProperties.AnchorMaxY;
}
if (wheelEffect)
{
driven |= DrivenTransformProperties.ScaleX | DrivenTransformProperties.ScaleY;
}
return(driven);
}
protected override void CustomLayoutRectTransform()
{
DrivenTransformProperties properties = DrivenTransformProperties.None;
properties |= DrivenTransformProperties.AnchorMinY
| DrivenTransformProperties.AnchorMaxY
| DrivenTransformProperties.PivotY;
tracker.Add(this, CachedRectTransform, properties);
if (direction == AlignDirection.BottomToTop)
{
CachedRectTransform.anchorMin = new Vector2(CachedRectTransform.anchorMin.x, 0);
CachedRectTransform.anchorMax = new Vector2(CachedRectTransform.anchorMax.x, 0);
CachedRectTransform.pivot = new Vector2(CachedRectTransform.pivot.x, 0);
}
else
{
CachedRectTransform.anchorMin = new Vector2(CachedRectTransform.anchorMin.x, 1);
CachedRectTransform.anchorMax = new Vector2(CachedRectTransform.anchorMax.x, 1);
CachedRectTransform.pivot = new Vector2(CachedRectTransform.pivot.x, 1);
}
}
protected override void OnValidate()
{
tracker.Clear();
if (content != null && !Application.isPlaying)
{
DrivenTransformProperties drivenProperties =
((scrollDir == ScrollDirection.Vertical) ? DrivenTransformProperties.AnchoredPositionY : DrivenTransformProperties.AnchoredPositionX) |
((scrollDir == ScrollDirection.Vertical) ? DrivenTransformProperties.AnchorMinY : DrivenTransformProperties.AnchorMinX) |
((scrollDir == ScrollDirection.Vertical) ? DrivenTransformProperties.AnchorMaxY : DrivenTransformProperties.AnchorMaxX) |
((scrollDir == ScrollDirection.Vertical) ? DrivenTransformProperties.PivotY : DrivenTransformProperties.PivotX) |
((scrollDir == ScrollDirection.Vertical) ? DrivenTransformProperties.SizeDeltaY : DrivenTransformProperties.SizeDeltaX);
tracker.Add(this, content, drivenProperties);
SetupRectTransform(content);
SetAnchoredPosition(content, 0);
content.sizeDelta = new Vector2(scrollDir == ScrollDirection.Vertical ? content.sizeDelta.x : 0,
scrollDir == ScrollDirection.Vertical ? 0 : content.sizeDelta.y);
}
}
protected override void CustomLayoutRectTransform()
{
DrivenTransformProperties properties = DrivenTransformProperties.None;
properties |= DrivenTransformProperties.AnchorMinX
| DrivenTransformProperties.AnchorMaxX
| DrivenTransformProperties.PivotX;
tracker.Add(this, CachedRectTransform, properties);
if (direction == AlignDirection.LeftToRight)
{
CachedRectTransform.anchorMin = new Vector2(0, CachedRectTransform.anchorMin.y);
CachedRectTransform.anchorMax = new Vector2(0, CachedRectTransform.anchorMax.y);
CachedRectTransform.pivot = new Vector2(0, CachedRectTransform.pivot.y);
}
else
{
CachedRectTransform.anchorMin = new Vector2(1, CachedRectTransform.anchorMin.y);
CachedRectTransform.anchorMax = new Vector2(1, CachedRectTransform.anchorMax.y);
CachedRectTransform.pivot = new Vector2(1, CachedRectTransform.pivot.y);
}
}
protected virtual float AlignChild(RectTransform child, ref float offset)
{
float directionScale = (direction == AlignDirection.LeftToRight) ? 1 : -1;
float anchorX = (direction == AlignDirection.LeftToRight) ? 0 : 1;
DrivenTransformProperties childProperties =
DrivenTransformProperties.AnchorMinX
| DrivenTransformProperties.AnchorMaxX
| DrivenTransformProperties.AnchoredPositionX;
tracker.Add(this, child, childProperties);
child.anchorMin = new Vector2(anchorX, child.anchorMin.y);
child.anchorMax = new Vector2(anchorX, child.anchorMax.y);
CustomChild(child, offset);
float w = child.rect.width * Mathf.Abs(child.localScale.x);
offset += directionScale * (w * child.pivot.x);
child.anchoredPosition = new Vector2(offset, child.anchoredPosition.y);
offset += directionScale * (w * (1.0f - child.pivot.x) + space);
return(w);
}
protected virtual float AlignChild(RectTransform child, ref float offset)
{
float directionScale = (direction == AlignDirection.BottomToTop) ? 1 : -1;
float anchorY = (direction == AlignDirection.BottomToTop) ? 0 : 1;
DrivenTransformProperties childProperties =
DrivenTransformProperties.AnchorMinY
| DrivenTransformProperties.AnchorMaxY
| DrivenTransformProperties.AnchoredPositionY;
tracker.Add(this, child, childProperties);
child.anchorMin = new Vector2(child.anchorMin.x, anchorY);
child.anchorMax = new Vector2(child.anchorMax.x, anchorY);
CustomChild(child, offset);
float h = child.rect.height * Mathf.Abs(child.localScale.y);
offset += directionScale * (h * child.pivot.y);
child.anchoredPosition = new Vector2(child.anchoredPosition.x, offset);
offset += directionScale * (h * (1.0f - child.pivot.y) + space);
return(h);
}
private void Layout()
{
this.m_Tracker.Clear();
if (base.transform.childCount == 0)
{
return;
}
float num = (this.maxAngle - this.minAngle) / (float)base.transform.childCount;
for (int i = 0; i < base.transform.childCount; i++)
{
RectTransform rectTransform = (RectTransform)base.transform.GetChild(i);
float num2 = this.startAngle + (float)i * num;
Vector3 vector = new Vector3(Mathf.Cos(num2 * 0.0174532924f), Mathf.Sin(num2 * 0.0174532924f));
rectTransform.localPosition = vector * this.distance;
DrivenTransformProperties drivenTransformProperties = (DrivenTransformProperties)52998;
this.m_Tracker.Add(this, rectTransform, drivenTransformProperties);
rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
rectTransform.pivot = new Vector2(0.5f, 0.5f);
}
}
private void Vector2Field(Rect position, Func <float> xGetter, Action <float> xSetter, Func <float> yGetter, Action <float> ySetter,
DrivenTransformProperties xDriven, DrivenTransformProperties yDriven, SerializedProperty xProperty, SerializedProperty yProperty, GUIContent label)
{
EditorGUI.PrefixLabel(position, -1, label);
float lblW = EditorGUIUtility.labelWidth;
int ident = EditorGUI.indentLevel;
Rect columnRect = this.GetColumnRect(position, 0);
Rect rect = this.GetColumnRect(position, 1);
EditorGUIUtility.labelWidth = 13f;
EditorGUI.indentLevel = 0;
EditorGUI.BeginProperty(columnRect, Styles.X, xProperty);
this.FloatField(columnRect, xGetter, xSetter, xDriven, Styles.X);
EditorGUI.EndProperty();
EditorGUI.BeginProperty(columnRect, Styles.Y, yProperty);
this.FloatField(rect, yGetter, ySetter, yDriven, Styles.Y);
EditorGUI.EndProperty();
EditorGUIUtility.labelWidth = lblW;
EditorGUI.indentLevel = ident;
}
public void CalculateRadial()
{
int activeChildCount = 0;
List <RectTransform> childList = new List <RectTransform> ();
for (int i = 0; i < transform.childCount; i++)
{
RectTransform child = transform.GetChild(i) as RectTransform;
LayoutElement childLayout = child.GetComponent <LayoutElement> ();
if (child == null || !child.gameObject.activeSelf || (childLayout != null && childLayout.ignoreLayout))
{
continue;
}
childList.Add(child);
activeChildCount++;
}
m_Tracker.Clear();
if (activeChildCount == 0)
{
return;
}
// Set maxAngle and startAngle based on the number of children (cards).
if (activeChildCount >= 5)
{
maxAngle = 40;
}
else
{
maxAngle = (activeChildCount - 1f) * 10f;
}
startAngle = 90 + maxAngle / 2f;
rectTransform.sizeDelta = new Vector2(radius, radius) * 2f;
float sAngle = ((360f) / activeChildCount) * (activeChildCount - 1f);
float anglOffset = minAngle;
if (anglOffset > sAngle)
{
anglOffset = sAngle;
}
// Set the amount of space between the children, as well as the starting angle.
float fOffsetAngle = maxAngle / (activeChildCount - 1f);
float fAngle = startAngle + anglOffset;
// Set the rotation as a driven property.
DrivenTransformProperties drivenTransformProperties = DrivenTransformProperties.Anchors | DrivenTransformProperties.AnchoredPosition | DrivenTransformProperties.Pivot;
if (rotateElements)
{
drivenTransformProperties |= DrivenTransformProperties.Rotation;
}
// Alter direction for clockwise rotations
if (clockwise)
{
fOffsetAngle *= -1f;
}
// Set positions for all children.
for (int i = 0; i < childList.Count; i++)
{
RectTransform child = childList[i];
if (child != null && child.gameObject.activeSelf)
{
// Adding the elements to the tracker stops the user from modifiying their positions via the editor.
m_Tracker.Add(this, child, drivenTransformProperties);
Vector3 vPos = new Vector3(Mathf.Cos(fAngle * Mathf.Deg2Rad), Mathf.Sin(fAngle * Mathf.Deg2Rad), 0);
child.localPosition = vPos * radius;
// Force objects to be center aligned, this can be changed however I'd suggest you keep all of the objects with the same anchor points.
child.anchorMin = child.anchorMax = child.pivot = new Vector2(0.5f, 0.5f);
// Rotate children
float elementAngle = startElementAngle;
if (rotateElements)
{
elementAngle += fAngle;
child.localEulerAngles = new Vector3(0f, 0f, elementAngle);
}
else
{
child.localEulerAngles = new Vector3(0f, 0f, elementAngle);
}
fAngle += fOffsetAngle;
}
}
}
private void FloatField(Rect position, Func <float> getter, Action <float> setter, DrivenTransformProperties driven, GUIContent label, bool labelAbove = false)
{
float val = getter();
EditorGUI.BeginChangeCheck();
float newVal;
if (labelAbove)
{
int controlID = GUIUtility.GetControlID(BetterLocatorEditor.floatFieldHash, FocusType.Keyboard, position);
Rect rect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight);
Rect rect1 = new Rect(position.x, position.y + EditorGUIUtility.singleLineHeight, position.width, EditorGUIUtility.singleLineHeight);
EditorGUI.HandlePrefixLabel(position, rect, label, controlID);
EditorGUI.PrefixLabel(rect, label);
newVal = EditorGUI.FloatField(rect1, val);
}
else
{
newVal = EditorGUI.FloatField(position, label, val);
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(base.target, "Inspector");
setter(newVal);
}
}
//#if UNITY_EDITOR
//
// protected override void OnValidate()
// {
// base.OnValidate();
// CalculateRadial();
// }
//
//#endif
#endregion
#region Public Methods
/// <summary> Rebuild the layout </summary>
public void CalculateRadial()
{
if (m_childList == null)
{
m_childList = new List <RectTransform>();
}
m_childList.Clear();
int activeChildCount = 0;
for (int i = 0; i < transform.childCount; i++)
{
var child = transform.GetChild(i) as RectTransform;
if (child == null)
{
continue;
}
var childButton = child.GetComponent <UIButton>();
if (childButton != null)
{
childButton.UpdateStartValues();
}
var childToggle = child.GetComponent <UIToggle>();
if (childToggle != null)
{
childToggle.UpdateStartValues();
}
var childLayout = child.GetComponent <LayoutElement>();
if (child == null || !child.gameObject.activeSelf || (childLayout != null && childLayout.ignoreLayout))
{
continue;
}
m_childList.Add(child);
activeChildCount++;
}
m_Tracker.Clear();
if (activeChildCount == 0)
{
return;
}
RectTransform.sizeDelta = new Vector2(m_Radius, m_Radius) * 2f;
float sAngle = 360f / activeChildCount * (activeChildCount - 1f);
float angleOffset = m_MinAngle;
if (angleOffset > sAngle)
{
angleOffset = sAngle;
}
float maxAngle = 360f - m_MaxAngle;
if (maxAngle > sAngle)
{
maxAngle = sAngle;
}
if (angleOffset > sAngle)
{
angleOffset = sAngle;
}
float buff = sAngle - angleOffset;
float fOffsetAngle = ((buff - maxAngle)) / (activeChildCount - 1f) + m_Spacing;
float fAngle = m_StartAngle + angleOffset;
bool controlChildrenSize = m_ControlChildWidth | m_ControlChildHeight;
DrivenTransformProperties drivenTransformProperties = DrivenTransformProperties.Anchors | DrivenTransformProperties.AnchoredPosition | DrivenTransformProperties.Pivot;
if (m_ControlChildWidth)
{
drivenTransformProperties |= DrivenTransformProperties.SizeDeltaX;
}
if (m_ControlChildHeight)
{
drivenTransformProperties |= DrivenTransformProperties.SizeDeltaY;
}
if (m_RotateChildren)
{
drivenTransformProperties |= DrivenTransformProperties.Rotation;
}
if (m_Clockwise)
{
fOffsetAngle *= -1f;
}
foreach (RectTransform child in m_childList)
{
if (child == null || !child.gameObject.activeSelf)
{
continue; //if child is null or not active -> continue
}
m_Tracker.Add(this, child, drivenTransformProperties); //add elements to the tracker to stop the user from modifying their positions via the editor
var vPos = new Vector3(Mathf.Cos(fAngle * Mathf.Deg2Rad), Mathf.Sin(fAngle * Mathf.Deg2Rad), 0); //calculate the child position
child.localPosition = vPos * m_Radius; //set the child position
child.anchorMin = child.anchorMax = child.pivot = new Vector2(0.5f, 0.5f); //force children to be center aligned, to keep all of the objects with the same anchor points
float elementAngle = m_ChildRotation;
if (m_RotateChildren)
{
elementAngle += fAngle;
}
child.localEulerAngles = new Vector3(0f, 0f, elementAngle);
if (controlChildrenSize)
{
Vector2 childSizeDelta = child.sizeDelta;
if (ControlChildWidth)
{
childSizeDelta.x = m_RadiusControlsWidth
? m_ChildWidth * m_Radius * m_RadiusWidthFactor / 100
: m_ChildWidth;
}
if (ControlChildHeight)
{
childSizeDelta.y = m_RadiusControlsHeight
? m_ChildHeight * m_Radius * m_RadiusHeightFactor / 100
: m_ChildHeight;
}
child.sizeDelta = childSizeDelta;
}
fAngle += fOffsetAngle;
}
}
protected void SetChildAlongAxis(RectTransform rect, int axis, float pos, float size, DrivenTransformProperties properties)
{
if (!rect)
{
return;
}
m_Tracker.Add(this, rect, properties);
rect.SetInsetAndSizeFromParentEdge(axis != 0 ? RectTransform.Edge.Bottom : RectTransform.Edge.Left, pos, size);
}
private void FloatFieldLabelAbove(Rect position, RectTransformEditor.FloatGetter getter, RectTransformEditor.FloatSetter setter, DrivenTransformProperties driven, GUIContent label)
{
EditorGUI.BeginDisabledGroup(base.targets.Any((UnityEngine.Object x) => ((x as RectTransform).drivenProperties & driven) != DrivenTransformProperties.None));
float value = getter(this.target as RectTransform);
EditorGUI.showMixedValue = ((
from x in base.targets
select getter(x as RectTransform)).Distinct<float>().Count<float>() >= 2);
EditorGUI.BeginChangeCheck();
int controlID = GUIUtility.GetControlID(RectTransformEditor.s_FloatFieldHash, FocusType.Keyboard, position);
Rect rect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight);
Rect position2 = new Rect(position.x, position.y + EditorGUIUtility.singleLineHeight, position.width, EditorGUIUtility.singleLineHeight);
EditorGUI.HandlePrefixLabel(position, rect, label, controlID);
float f = EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor, position2, rect, controlID, value, EditorGUI.kFloatFieldFormatString, EditorStyles.textField, true);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(base.targets, "Inspector");
UnityEngine.Object[] targets = base.targets;
for (int i = 0; i < targets.Length; i++)
{
RectTransform rect2 = (RectTransform)targets[i];
setter(rect2, f);
}
}
EditorGUI.EndDisabledGroup();
}
private void FloatFieldLabelAbove(Rect position, RectTransformEditor.FloatGetter getter, RectTransformEditor.FloatSetter setter, DrivenTransformProperties driven, GUIContent label)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: variable of a compiler-generated type
RectTransformEditor.\u003CFloatFieldLabelAbove\u003Ec__AnonStorey98 aboveCAnonStorey98 = new RectTransformEditor.\u003CFloatFieldLabelAbove\u003Ec__AnonStorey98();
// ISSUE: reference to a compiler-generated field
aboveCAnonStorey98.driven = driven;
// ISSUE: reference to a compiler-generated field
aboveCAnonStorey98.getter = getter;
// ISSUE: reference to a compiler-generated method
EditorGUI.BeginDisabledGroup(((IEnumerable<UnityEngine.Object>) this.targets).Any<UnityEngine.Object>(new Func<UnityEngine.Object, bool>(aboveCAnonStorey98.\u003C\u003Em__1AD)));
// ISSUE: reference to a compiler-generated field
float num = aboveCAnonStorey98.getter(this.target as RectTransform);
// ISSUE: reference to a compiler-generated method
EditorGUI.showMixedValue = ((IEnumerable<UnityEngine.Object>) this.targets).Select<UnityEngine.Object, float>(new Func<UnityEngine.Object, float>(aboveCAnonStorey98.\u003C\u003Em__1AE)).Distinct<float>().Count<float>() >= 2;
EditorGUI.BeginChangeCheck();
int controlId = GUIUtility.GetControlID(RectTransformEditor.s_FloatFieldHash, FocusType.Keyboard, position);
Rect rect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight);
Rect position1 = new Rect(position.x, position.y + EditorGUIUtility.singleLineHeight, position.width, EditorGUIUtility.singleLineHeight);
EditorGUI.HandlePrefixLabel(position, rect, label, controlId);
float f = EditorGUI.DoFloatField(EditorGUI.s_RecycledEditor, position1, rect, controlId, num, EditorGUI.kFloatFieldFormatString, EditorStyles.textField, true);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(this.targets, "Inspector");
foreach (RectTransform target in this.targets)
setter(target, f);
}
EditorGUI.EndDisabledGroup();
}
private void Vector2Field(Rect position, RectTransformEditor.FloatGetter xGetter, RectTransformEditor.FloatSetter xSetter, RectTransformEditor.FloatGetter yGetter, RectTransformEditor.FloatSetter ySetter, DrivenTransformProperties xDriven, DrivenTransformProperties yDriven, SerializedProperty xProperty, SerializedProperty yProperty, GUIContent label)
{
EditorGUI.PrefixLabel(position, -1, label);
float labelWidth = EditorGUIUtility.labelWidth;
int indentLevel = EditorGUI.indentLevel;
Rect columnRect = this.GetColumnRect(position, 0);
Rect columnRect2 = this.GetColumnRect(position, 1);
EditorGUIUtility.labelWidth = 13f;
EditorGUI.indentLevel = 0;
EditorGUI.BeginProperty(columnRect, RectTransformEditor.s_XYLabels[0], xProperty);
this.FloatField(columnRect, xGetter, xSetter, xDriven, RectTransformEditor.s_XYLabels[0]);
EditorGUI.EndProperty();
EditorGUI.BeginProperty(columnRect, RectTransformEditor.s_XYLabels[1], yProperty);
this.FloatField(columnRect2, yGetter, ySetter, yDriven, RectTransformEditor.s_XYLabels[1]);
EditorGUI.EndProperty();
EditorGUIUtility.labelWidth = labelWidth;
EditorGUI.indentLevel = indentLevel;
}
private void FloatField(Rect position, RectTransformEditor.FloatGetter getter, RectTransformEditor.FloatSetter setter, DrivenTransformProperties driven, GUIContent label)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: variable of a compiler-generated type
RectTransformEditor.\u003CFloatField\u003Ec__AnonStorey99 fieldCAnonStorey99 = new RectTransformEditor.\u003CFloatField\u003Ec__AnonStorey99();
// ISSUE: reference to a compiler-generated field
fieldCAnonStorey99.driven = driven;
// ISSUE: reference to a compiler-generated field
fieldCAnonStorey99.getter = getter;
// ISSUE: reference to a compiler-generated method
EditorGUI.BeginDisabledGroup(((IEnumerable<UnityEngine.Object>) this.targets).Any<UnityEngine.Object>(new Func<UnityEngine.Object, bool>(fieldCAnonStorey99.\u003C\u003Em__1AF)));
// ISSUE: reference to a compiler-generated field
float num = fieldCAnonStorey99.getter(this.target as RectTransform);
// ISSUE: reference to a compiler-generated method
EditorGUI.showMixedValue = ((IEnumerable<UnityEngine.Object>) this.targets).Select<UnityEngine.Object, float>(new Func<UnityEngine.Object, float>(fieldCAnonStorey99.\u003C\u003Em__1B0)).Distinct<float>().Count<float>() >= 2;
EditorGUI.BeginChangeCheck();
float f = EditorGUI.FloatField(position, label, num);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(this.targets, "Inspector");
foreach (RectTransform target in this.targets)
setter(target, f);
}
EditorGUI.EndDisabledGroup();
}
private void FloatField(Rect position, RectTransformEditor.FloatGetter getter, RectTransformEditor.FloatSetter setter, DrivenTransformProperties driven, GUIContent label)
{
EditorGUI.BeginDisabledGroup(base.targets.Any((UnityEngine.Object x) => ((x as RectTransform).drivenProperties & driven) != DrivenTransformProperties.None));
float value = getter(this.target as RectTransform);
EditorGUI.showMixedValue = ((
from x in base.targets
select getter(x as RectTransform)).Distinct<float>().Count<float>() >= 2);
EditorGUI.BeginChangeCheck();
float f = EditorGUI.FloatField(position, label, value);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(base.targets, "Inspector");
UnityEngine.Object[] targets = base.targets;
for (int i = 0; i < targets.Length; i++)
{
RectTransform rect = (RectTransform)targets[i];
setter(rect, f);
}
}
EditorGUI.EndDisabledGroup();
}
// Methods
public void Add(Object driver, RectTransform rectTransform, DrivenTransformProperties drivenProperties)
{
} // 0x0000000180002ED0-0x0000000180002EE0
public void CalculateRadial()
{
int activeChildCount = 0;
List <RectTransform> childList = new List <RectTransform> ();
for (int i = 0; i < transform.childCount; i++)
{
RectTransform child = transform.GetChild(i) as RectTransform;
LayoutElement childLayout = child.GetComponent <LayoutElement> ();
if (child == null || !child.gameObject.activeSelf || (childLayout != null && childLayout.ignoreLayout))
{
continue;
}
childList.Add(child);
activeChildCount++;
}
m_Tracker.Clear();
if (activeChildCount == 0)
{
return;
}
rectTransform.sizeDelta = new Vector2(radius, radius) * 2f;
float sAngle = ((360f) / activeChildCount) * (activeChildCount - 1f);
float anglOffset = minAngle;
if (anglOffset > sAngle)
{
anglOffset = sAngle;
}
float buff = sAngle - anglOffset;
float maxAngl = 360f - maxAngle;
if (maxAngl > sAngle)
{
maxAngl = sAngle;
}
if (anglOffset > sAngle)
{
anglOffset = sAngle;
}
buff = sAngle - anglOffset;
float fOffsetAngle = ((buff - maxAngl)) / (activeChildCount - 1f);
float fAngle = startAngle + anglOffset;
float countWidthFactor = fOffsetAngle < maxWidthFactor ? fOffsetAngle : maxWidthFactor;
bool expandChilds = expandChildWidth | expandChildHeight;
DrivenTransformProperties drivenTransformProperties = DrivenTransformProperties.Anchors | DrivenTransformProperties.AnchoredPosition | DrivenTransformProperties.Pivot;
if (expandChildWidth)
{
drivenTransformProperties |= DrivenTransformProperties.SizeDeltaX;
}
if (expandChildHeight)
{
drivenTransformProperties |= DrivenTransformProperties.SizeDeltaY;
}
if (rotateElements)
{
drivenTransformProperties |= DrivenTransformProperties.Rotation;
}
if (clockwise)
{
fOffsetAngle *= -1f;
}
for (int i = 0; i < childList.Count; i++)
{
RectTransform child = childList[i];
if (child != null && child.gameObject.activeSelf)
{
//Adding the elements to the tracker stops the user from modifiying their positions via the editor.
m_Tracker.Add(this, child, drivenTransformProperties);
Vector3 vPos = new Vector3(Mathf.Cos(fAngle * Mathf.Deg2Rad), Mathf.Sin(fAngle * Mathf.Deg2Rad), 0);
child.localPosition = vPos * radius;
//Force objects to be center aligned, this can be changed however I'd suggest you keep all of the objects with the same anchor points.
child.anchorMin = child.anchorMax = child.pivot = new Vector2(0.5f, 0.5f);
float elementAngle = startElementAngle;
if (rotateElements)
{
elementAngle += fAngle;
child.localEulerAngles = new Vector3(0f, 0f, elementAngle);
}
else
{
child.localEulerAngles = new Vector3(0f, 0f, elementAngle);
}
if (expandChilds)
{
Vector2 expandSize = child.sizeDelta;
if (expandChildWidth)
{
expandSize.x = childWidthFromRadius ? (radius * childWidthRadiusFactor) * countWidthFactor * childWidthFactor : countWidthFactor * childWidthFactor;
}
if (expandChildHeight)
{
expandSize.y = childHeightFromRadius ? (radius * childHeightRadiusFactor) * childHeight : childHeight;
}
child.sizeDelta = expandSize;
}
fAngle += fOffsetAngle;
}
}
}
protected virtual void SetLayout(int axis)
{
if (scrollRect == null)
{
return;
}
if (axis != GetAxisIndex())
{
return;
}
if (m_LockSetLayout)
{
m_DirtyLayout = true;
return;
}
Vector2 scrollAreaSize = GetScrollAreaSize();
m_Tracker.Clear();
rectChildren.Clear();
m_itemOffsetList.Clear();
m_pickerItemList.Clear();
m_childTransformList.Clear();
cacheRect.Clear();
bool infinite = m_ScrollRect.infiniteScroll;
bool wheelEffect = m_ScrollRect.wheelEffect;
WheelEffect3D wheelEffect3D = GetComponentInParent <WheelEffect3D>();
if (wheelEffect3D != null)
{
if (wheelEffect3D.IsActive() && (int)wheelEffect3D.layout == axis)
{
wheelEffect = true;
}
else
{
wheelEffect3D = null;
}
}
DrivenTransformProperties childDriven = GetChildPropertyDriven(axis, wheelEffect);
float position = (!infinite ? scrollAreaSize[axis] * 0.5f : 0);
float scrollSize = position;
for (int childIndex = 0; childIndex < rectTransform.childCount; childIndex++)
{
Transform childTransform = rectTransform.GetChild(childIndex);
RectTransform childRectTransform;
ItemComponent itemComponent;
PickerItem item;
if (!m_ChildItemTable.TryGetValue(childTransform, out itemComponent))
{
childRectTransform = childTransform as RectTransform;
item = childRectTransform.GetComponent <PickerItem>();
m_ChildItemTable[childTransform] = new ItemComponent()
{
item = item, rectTransform = childRectTransform
};
}
else
{
childRectTransform = itemComponent.rectTransform;
item = itemComponent.item;
}
if (item == null || !item.enabled || !childRectTransform.gameObject.activeInHierarchy)
{
continue;
}
rectChildren.Add(childRectTransform);
m_pickerItemList.Add(item);
m_itemOffsetList.Add(0);
m_childTransformList.Add(childRectTransform);
m_Tracker.Add(this, childRectTransform, childDriven);
{
Vector2 anchorMin = childRectTransform.anchorMin;
if (anchorMin[axis] != 0.5f)
{
anchorMin[axis] = 0.5f;
childRectTransform.anchorMin = anchorMin;
}
Vector2 anchorMax = childRectTransform.anchorMax;
if (anchorMax[axis] != 0.5f)
{
anchorMax[axis] = 0.5f;
childRectTransform.anchorMax = anchorMax;
}
}
Rect rect = childRectTransform.rect;
cacheRect.Add(rect);
float size = rect.size[axis];
scrollSize += spacing + size;
}
if (m_childTransformList.Count > 0 && !infinite)
{
float size = m_childTransformList[0].rect.size[axis];
position -= size * 0.5f;
scrollSize -= size * 0.5f;
size = m_childTransformList[m_childTransformList.Count - 1].rect.size[axis];
scrollSize -= size * 0.5f;
scrollSize -= spacing;
}
if (!infinite)
{
float flex = Mathf.Min(scrollSize * 0.002f, 0.1f);
scrollSize += scrollAreaSize[axis] * 0.5f + flex + flex;
position += flex;
}
SetContentRectSize(axis, scrollSize);
position += scrollSize * -0.5f;
float pivot = m_ChildPivot - 0.5f;
float direction = (axis == 0 ? 1f : -1f);
float wheelPosition = scrollRect.content.localPosition[axis] * -direction;
float infiniteOffsetFloor = 0;
if (infinite)
{
infiniteOffsetFloor = Mathf.Floor(wheelPosition / scrollSize) * scrollSize;
}
if (wheelEffect)
{
float perspective = m_ScrollRect.wheelPerspective;
float wheelRadius = wheelEffect3D != null ? wheelEffect3D.radius : scrollAreaSize[axis] * 0.5f;
float circumference = (wheelRadius + wheelRadius) * Mathf.PI;
float ru = (Mathf.PI + Mathf.PI) / circumference * direction;
for (int childIndex = 0; childIndex < m_childTransformList.Count; ++childIndex)
{
RectTransform childTransform = m_childTransformList[childIndex];
float size = cacheRect[childIndex].size[axis];
float tmp;
if (!infinite)
{
tmp = position + size * 0.5f;
}
else
{
tmp = infiniteOffsetFloor + position + size * 0.5f;
if (Mathf.Abs(tmp - wheelPosition) > Mathf.Abs(tmp + scrollSize - wheelPosition))
{
tmp += scrollSize;
}
}
position += size + spacing;
float rad = (tmp - wheelPosition) * ru;
float offset = tmp * direction;
m_itemOffsetList[childIndex] = offset;
PickerItem item = m_pickerItemList[childIndex];
item.position = -offset;
if (Mathf.Abs(rad) < Mathf.PI * 0.5f)
{
if (wheelEffect3D == null)
{
float scale = Mathf.Cos(rad);
Vector3 localScale = childTransform.localScale;
localScale[axis] = scale;
float scale2 = (1 - perspective) + scale * perspective;
localScale[1 - axis] = scale2;
childTransform.localScale = localScale;
Vector2 center = cacheRect[childIndex].center;
Vector3 childPosition = Vector2.zero;
childPosition[axis] = Mathf.Sin(rad) * wheelRadius + wheelPosition * direction - center[axis] * scale;
float childPivot = childTransform.pivot[1 - axis] - 0.5f;
float childAnchorMin = childTransform.anchorMin[1 - axis];
float childAnchorMax = childTransform.anchorMax[1 - axis];
float revision = (childPivot * (childAnchorMax - childAnchorMin) + (childAnchorMax + childAnchorMin - 1) * 0.5f) * scrollAreaSize[1 - axis];
childPosition[1 - axis] = (scrollAreaSize[1 - axis] - cacheRect[childIndex].size[1 - axis] * scale2) * pivot - center[1 - axis] * scale2 - revision;
childPosition.z = 0;
childTransform.localPosition = childPosition;
if (childTransform.localRotation != Quaternion.identity)
{
childTransform.localRotation = Quaternion.identity;
}
}
else
{
Vector2 center = cacheRect[childIndex].center;
Vector3 childPosition = Vector3.zero;
childPosition[axis] = Mathf.Sin(rad) * wheelRadius + wheelPosition * direction - center[axis];
Vector3 eulerAngles = childTransform.localRotation.eulerAngles;
eulerAngles[1 - axis] = rad * -Mathf.Rad2Deg * direction;
childTransform.localRotation = Quaternion.Euler(eulerAngles);
float childPivot = childTransform.pivot[1 - axis] - 0.5f;
float childAnchorMin = childTransform.anchorMin[1 - axis];
float childAnchorMax = childTransform.anchorMax[1 - axis];
float revision = (childPivot * (childAnchorMax - childAnchorMin) + (childAnchorMax + childAnchorMin - 1) * 0.5f) * scrollAreaSize[1 - axis];
childPosition[1 - axis] = (scrollAreaSize[1 - axis] - cacheRect[childIndex].size[1 - axis]) * pivot - center[1 - axis] - revision;
childPosition.z = wheelRadius - Mathf.Cos(rad) * wheelRadius;
if (childTransform.localScale != Vector3.one)
{
childTransform.localScale = Vector3.one;
}
childTransform.localPosition = childPosition;
}
}
else
{
Vector3 scale = childTransform.localScale;
if (scale.x != 0 || scale.y != 0)
{
scale.x = 0;
scale.y = 0;
childTransform.localScale = scale;
}
}
}
}
else
{
for (int childIndex = 0; childIndex < m_childTransformList.Count; ++childIndex)
{
RectTransform childTransform = m_childTransformList[childIndex];
PickerItem item = m_pickerItemList[childIndex];
Rect rect = childTransform.rect;
float size = rect.size[axis];
float tmp;
if (!infinite)
{
tmp = position + size * 0.5f;
}
else
{
tmp = infiniteOffsetFloor + position + size * 0.5f;
if (Mathf.Abs(tmp - wheelPosition) > Mathf.Abs(tmp + scrollSize - wheelPosition))
{
tmp += scrollSize;
}
}
float offset = tmp * direction;
m_itemOffsetList[childIndex] = offset;
item.position = -offset;
position += size + spacing;
Vector3 childPosition = childTransform.anchoredPosition;
childPosition[axis] = tmp * direction - rect.center[axis];
float childPivot = childTransform.pivot[1 - axis] - 0.5f;
float childAnchorMin = childTransform.anchorMin[1 - axis];
float childAnchorMax = childTransform.anchorMax[1 - axis];
float revision = (childPivot * (childAnchorMax - childAnchorMin) + (childAnchorMax + childAnchorMin - 1) * 0.5f) * scrollAreaSize[1 - axis];
childPosition[1 - axis] = (scrollAreaSize[1 - axis] - rect.size[1 - axis]) * pivot - rect.center[1 - axis] - revision;
childPosition.z = 0;
if (childTransform.localPosition != childPosition)
{
childTransform.localPosition = childPosition;
}
if (childTransform.localRotation != Quaternion.identity)
{
childTransform.localRotation = Quaternion.identity;
}
if (childTransform.localScale != Vector3.one)
{
childTransform.localScale = Vector3.one;
}
}
}
if (direction < 0)
{
m_itemOffsetList.Reverse();
m_pickerItemList.Reverse();
}
int infiniteScrollOffset = 0;
if (infinite)
{
//sort offset & item
int i;
int count = m_itemOffsetList.Count;
if (count > 1)
{
for (i = 1; i < count; ++i)
{
if (m_itemOffsetList[i - 1] >= m_itemOffsetList[i])
{
break;
}
}
infiniteScrollOffset = i;
if (i < count)
{
if (swapBufferOffset == null || i > swapBufferOffset.Length)
{
swapBufferOffset = new float[i];
swapBufferItem = new PickerItem[i];
}
m_itemOffsetList.CopyTo(0, swapBufferOffset, 0, i);
m_pickerItemList.CopyTo(0, swapBufferItem, 0, i);
int j;
for (j = 0; j + i < count; ++j)
{
m_itemOffsetList[j] = m_itemOffsetList[j + i];
m_pickerItemList[j] = m_pickerItemList[j + i];
}
for (int k = 0; k + j < count; ++k)
{
m_itemOffsetList[k + j] = swapBufferOffset[k];
m_pickerItemList[k + j] = swapBufferItem[k];
}
}
}
}
if (scrollRect != null && Application.isPlaying)
{
scrollRect.SetInitialPosition(infiniteScrollOffset);
}
}
//
// Summary:
// Resume recording undo of driven RectTransforms.
//public static void StartRecordingUndo();
//
// Summary:
// Stop recording undo actions from driven RectTransforms.
//public static void StopRecordingUndo();
//
// Summary:
// Add a RectTransform to be driven.
//
// Parameters:
// driver:
// The object to drive properties.
//
// rectTransform:
// The RectTransform to be driven.
//
// drivenProperties:
// The properties to be driven.
public void Add(Object driver, RectTransform rectTransform, DrivenTransformProperties drivenProperties)
{
}
private void FloatFieldLabelAbove(Rect position, Func <float> getter, Action <float> setter, DrivenTransformProperties driven, GUIContent label)
{
FloatField(position, getter, setter, driven, label, true);
}
