ObjectCollection.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using System.Collections.Generic;
using UnityEngine;

namespace HoloToolkit.Unity.Collections
{
    public class ObjectCollection : MonoBehaviour
    {
        #region public members
        public Action<ObjectCollection> OnCollectionUpdated;

        [SerializeField]
        public List<CollectionNode> NodeList = new List<CollectionNode>();

        [Tooltip("Type of surface to map the collection to")]
        public SurfaceTypeEnum SurfaceType = SurfaceTypeEnum.Plane;

        [Tooltip("Type of sorting to use")]
        public SortTypeEnum SortType = SortTypeEnum.None;

        [Tooltip("Should the objects in the collection be rotated / how should they be rotated")]
        public OrientTypeEnum OrientType = OrientTypeEnum.FaceOrigin;

        [Tooltip("Whether to sort objects by row first or by column first")]
        public LayoutTypeEnum LayoutType = LayoutTypeEnum.ColumnThenRow;

        public bool IgnoreInactiveTransforms = true;

        [Range(0.05f, 5.0f)]
        [Tooltip("Radius for the sphere or cylinder")]
        public float Radius = 2f;

        [SerializeField]
        [Tooltip("Radial range for radial layout")]
        [Range(5f, 360f)]
        private float radialRange = 180f;

        public float RadialRange
        {
            get { return radialRange; }
            set { radialRange = value; }
        }

        [Tooltip("Number of rows per column")]
        public int Rows = 3;

        [Tooltip("Width of cell per object")]
        public float CellWidth = 0.5f;

        [Tooltip("Height of cell per object")]
        public float CellHeight = 0.5f;

        [SerializeField]
        [Tooltip("Margin between objects horizontally")]
        private float horizontalMargin = 0.2f;

        public float HorizontalMargin
        {
            get { return horizontalMargin; }
            set { horizontalMargin = value; }
        }

        [SerializeField]
        [Tooltip("Margin between objects vertically")]
        private float verticalMargin = 0.2f;

        public float VerticalMargin
        {
            get { return verticalMargin; }
            set { verticalMargin = value; }
        }

        [SerializeField]
        [Tooltip("Margin between objects in depth")]
        private float depthMargin = 0.2f;

        public float DepthMargin
        {
            get { return depthMargin; }
            set { depthMargin = value; }
        }

        [HideInInspector]
        public Mesh SphereMesh;

        [HideInInspector]
        public Mesh CylinderMesh;

        public float Width { get; private set; }

        public float Height { get; private set; }
        #endregion

        #region private variables
        private int _columns;
        private float _circumference;
        private float _radialCellAngle;
        private Vector2 _halfCell;
        #endregion

        public void UpdateCollection()
        {
            // Check for empty nodes and remove them
            List<CollectionNode> emptyNodes = new List<CollectionNode>();

            for (int i = 0; i < NodeList.Count; i++)
            {
                if (NodeList[i].transform == null || (IgnoreInactiveTransforms && !NodeList[i].transform.gameObject.activeSelf) || NodeList[i].transform.parent==null || !(NodeList[i].transform.parent.gameObject==this.gameObject))
                {
                    emptyNodes.Add(NodeList[i]);
                }
            }

            // Now delete the empty nodes
            for (int i = 0; i < emptyNodes.Count; i++)
            {
                NodeList.Remove(emptyNodes[i]);
            }

            emptyNodes.Clear();

            // Check when children change and adjust
            for (int i = 0; i < this.transform.childCount; i++)
            {
                Transform child = this.transform.GetChild(i);

                if (!ContainsNode(child) && (child.gameObject.activeSelf || !IgnoreInactiveTransforms))
                {
                    CollectionNode node = new CollectionNode();

                    node.Name = child.name;
                    node.transform = child;
                    NodeList.Add(node);
                }
            }

            switch (SortType)
            {
                case SortTypeEnum.None:
                    break;

                case SortTypeEnum.Transform:
                    NodeList.Sort(delegate (CollectionNode c1, CollectionNode c2) { return c1.transform.GetSiblingIndex().CompareTo(c2.transform.GetSiblingIndex()); });
                    break;

                case SortTypeEnum.Alphabetical:
                    NodeList.Sort(delegate (CollectionNode c1, CollectionNode c2) { return c1.Name.CompareTo(c2.Name); });
                    break;

                case SortTypeEnum.AlphabeticalReversed:
                    NodeList.Sort(delegate (CollectionNode c1, CollectionNode c2) { return c1.Name.CompareTo(c2.Name); });
                    NodeList.Reverse();
                    break;

                case SortTypeEnum.TransformReversed:
                    NodeList.Sort(delegate (CollectionNode c1, CollectionNode c2) { return c1.transform.GetSiblingIndex().CompareTo(c2.transform.GetSiblingIndex()); });
                    NodeList.Reverse();
                    break;
            }

            _columns = Mathf.CeilToInt((float)NodeList.Count / Rows);
            Width = _columns * CellWidth;
            Height = Rows * CellHeight;
            _halfCell = new Vector2(CellWidth * 0.5f, CellHeight * 0.5f);
            _circumference = 2f * Mathf.PI * Radius;
            _radialCellAngle = RadialRange / _columns;

            LayoutChildren();

            if (OnCollectionUpdated != null)
            {
                OnCollectionUpdated.Invoke(this);
            }
        }

        private void LayoutChildren() {
        
            int cellCounter = 0;
            float startOffsetX;
            float startOffsetY;

            Vector3[] nodeGrid = new Vector3[NodeList.Count];
            Vector3 newPos = Vector3.zero;

            // Now lets lay out the grid
            startOffsetX = (_columns * 0.5f) * CellWidth;
            startOffsetY = (Rows * 0.5f) * CellHeight;

            cellCounter = 0;
            
            // First start with a grid then project onto surface
            switch (LayoutType)
            {
                case LayoutTypeEnum.ColumnThenRow:
                default:
                    for (int c = 0; c < _columns; c++)
                    {
                        for (int r = 0; r < Rows; r++)
                        {
                            if (cellCounter < NodeList.Count)
                            {
                                nodeGrid[cellCounter] = new Vector3((c * CellWidth) - startOffsetX + _halfCell.x, -(r * CellHeight) + startOffsetY - _halfCell.y, 0f) + (Vector3)((NodeList[cellCounter])).Offset;
                            }
                            cellCounter++;
                        }
                    }
                    break;

                case LayoutTypeEnum.RowThenColumn:
                    for (int r = 0; r < Rows; r++)
                    {
                        for (int c = 0; c < _columns; c++)
                        {
                            if (cellCounter < NodeList.Count)
                            {
                                nodeGrid[cellCounter] = new Vector3((c * CellWidth) - startOffsetX + _halfCell.x, -(r * CellHeight) + startOffsetY - _halfCell.y, 0f) + (Vector3)((NodeList[cellCounter])).Offset;
                            }
                            cellCounter++;
                        }
                    }
                    break;

            }

            switch (SurfaceType) {
                case SurfaceTypeEnum.Plane:
                    for (int i = 0; i < NodeList.Count; i++)
                    {
                        newPos = nodeGrid[i];
                        NodeList[i].transform.localPosition = newPos;
                        UpdateNodeFacing(NodeList[i], OrientType, newPos);
                    }
                    break;
                case SurfaceTypeEnum.Cylinder:
                    for (int i = 0; i < NodeList.Count; i++)
                    {
                        newPos = CylindricalMapping(nodeGrid[i], Radius);
                        NodeList[i].transform.localPosition = newPos;
                        UpdateNodeFacing(NodeList[i], OrientType, newPos);
                    }
                    break;
                case SurfaceTypeEnum.Sphere:

                    for (int i = 0; i < NodeList.Count; i++)
                    {
                        newPos = SphericalMapping(nodeGrid[i], Radius);
                        NodeList[i].transform.localPosition = newPos;
                        UpdateNodeFacing(NodeList[i], OrientType, newPos);
                    }
                    break;
                case SurfaceTypeEnum.Radial:
                    int curColumn = 0;
                    int curRow = 1;

                    for (int i = 0; i < NodeList.Count; i++)
                    {
                        newPos = RadialMapping(nodeGrid[i], Radius, curRow, curColumn);
                        if (curColumn == (_columns - 1))
                        {
                            curColumn = 0;
                            ++curRow;
                        }
                        else
                        {
                            ++curColumn;
                        }

                        NodeList[i].transform.localPosition = newPos;
                        UpdateNodeFacing(NodeList[i], OrientType, newPos);
                    }
                    break;
                case SurfaceTypeEnum.Scatter:
                    // Get randomized planar mapping
                    // Calculate radius of each node while we're here
                    // Then use the packer function to shift them into place
                    for (int i = 0; i < NodeList.Count; i++)
                    {
                        newPos = ScatterMapping (nodeGrid[i], Radius);
                        Collider nodeCollider = NodeList[i].transform.GetComponentInChildren<Collider>();
                        if (nodeCollider != null)
                        {
                            // Make the radius the largest of the object's dimensions to avoid overlap
                            Bounds bounds = nodeCollider.bounds;
                            NodeList[i].Radius = Mathf.Max (Mathf.Max(bounds.size.x, bounds.size.y), bounds.size.z) * 0.5f;
                        }
                        else
                        {
                            // Make the radius a default value
                            // TODO move this into a public field ?
                            NodeList[i].Radius = 1f;
                        }
                        NodeList[i].transform.localPosition = newPos;
                        UpdateNodeFacing(NodeList[i], OrientType, newPos);
                    }

                    // Iterate [x] times
                    // TODO move center, iterations and padding into a public field
                    for (int i = 0; i < 100; i++)
                    {
                        IterateScatterPacking (NodeList, Radius);
                    }
                    break;
            }
        }

        private void UpdateNodeFacing(CollectionNode node, OrientTypeEnum orientType, Vector3 newPos = default(Vector3))
        {
            Vector3 centerAxis;
            Vector3 pointOnAxisNearestNode;
            switch (OrientType)
            {
                case OrientTypeEnum.FaceOrigin:
                    node.transform.rotation = Quaternion.LookRotation(node.transform.position - this.transform.position, this.transform.up);
                    break;

                case OrientTypeEnum.FaceOriginReversed:
                    node.transform.rotation = Quaternion.LookRotation(this.transform.position - node.transform.position, this.transform.up);
                    break;

                case OrientTypeEnum.FaceCenterAxis:
                    centerAxis = Vector3.Project(node.transform.position - this.transform.position, this.transform.up);
                    pointOnAxisNearestNode = this.transform.position + centerAxis;
                    node.transform.rotation = Quaternion.LookRotation(node.transform.position - pointOnAxisNearestNode, this.transform.up);
                    break;

                case OrientTypeEnum.FaceCenterAxisReversed:
                    centerAxis = Vector3.Project(node.transform.position - this.transform.position, this.transform.up);
                    pointOnAxisNearestNode = this.transform.position + centerAxis;
                    node.transform.rotation = Quaternion.LookRotation(pointOnAxisNearestNode - node.transform.position, this.transform.up);
                    break;

                case OrientTypeEnum.FaceFoward:
                    node.transform.forward = transform.rotation * Vector3.forward;
                    break;

                case OrientTypeEnum.FaceForwardReversed:
                    node.transform.forward = transform.rotation * Vector3.back;
                    break;

                case OrientTypeEnum.FaceParentUp:
                    node.transform.forward = transform.rotation * Vector3.up;
                    break;

                case OrientTypeEnum.FaceParentDown:
                    node.transform.forward = transform.rotation * Vector3.down;
                    break;

                case OrientTypeEnum.None:
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
            }
        }


        private Vector3 SphericalMapping(Vector3 source, float radius)
        {
            Radius = radius >= 0 ? Radius : radius;
            Vector3 newPos = new Vector3(0f, 0f, Radius);

            float xAngle = (source.x / _circumference) * 360f;
            float yAngle = -(source.y / _circumference) * 360f;

            Quaternion rot = Quaternion.Euler(yAngle, xAngle, 0.0f);
            newPos = rot * newPos;

            return newPos;
        }

        private Vector3 CylindricalMapping(Vector3 source, float radius)
        {
            Radius = radius >= 0 ? Radius : radius;
            Vector3 newPos = new Vector3(0f, source.y, Radius);

            float xAngle = (source.x / _circumference) * 360f;

            Quaternion rot = Quaternion.Euler(0.0f, xAngle, 0.0f);
            newPos = rot * newPos;

            return newPos;
        }

        private Vector3 RadialMapping(Vector3 source, float radius, int row, int column)
        {
            Radius = radius >= 0 ? Radius : radius;

            source.x = 0f;
            source.y = 0f;
            source.z = (Radius / Rows) * row;

            float yAngle = _radialCellAngle * (column - (_columns * 0.5f)) + (_radialCellAngle * .5f);

            Quaternion rot = Quaternion.Euler(0.0f, yAngle, 0.0f);
            source = rot * source;

            return source;
        }

        private bool ContainsNode(Transform node)
        {
            for (int i = 0; i < NodeList.Count; i++)
            {
                if (NodeList[i] != null)
                {
                    if (NodeList[i].transform == node)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        private Vector3 ScatterMapping(Vector3 source, float radius)
        {
            source.x = UnityEngine.Random.Range(-radius, radius);
            source.y = UnityEngine.Random.Range(-radius, radius);
            return source;
        }

    
        private void IterateScatterPacking(List<CollectionNode> nodes, float radiusPadding)
        {
            // Sort by closest to center (don't worry about z axis)
            // Use the position of the collection as the packing center
            nodes.Sort(delegate (CollectionNode circle1, CollectionNode circle2) {
                float distance1 = (circle1.transform.localPosition).sqrMagnitude;
                float distance2 = (circle2.transform.localPosition).sqrMagnitude;
                return distance1.CompareTo(distance2);
            });
            
            Vector3 difference;
            Vector2 difference2D;

           // Move them closer together
           float radiusPaddingSquared = Mathf.Pow(radiusPadding, 2f);

           for (int i = 0; i < nodes.Count - 1; i++)
           {
                for (int j = i + 1; j < nodes.Count; j++)
                {
                    if (i != j)
                    {
                        difference = nodes[j].transform.localPosition - nodes[i].transform.localPosition;
                        // Ignore Z axis
                        difference2D.x = difference.x;
                        difference2D.y = difference.y;
                        float combinedRadius = nodes[i].Radius + nodes[j].Radius;
                        float distance = difference2D.SqrMagnitude() - radiusPaddingSquared;
                        float minSeparation = Mathf.Min(distance, radiusPaddingSquared);
                        distance -= minSeparation;

                        if (distance < (Mathf.Pow(combinedRadius, 2)))
                        {
                            difference2D.Normalize();
                            difference *= ((combinedRadius - Mathf.Sqrt(distance)) * 0.5f);
                            nodes[j].transform.localPosition += difference;
                            nodes[i].transform.localPosition -= difference;
                        }
                    }
                }
            }
        }

        protected virtual void OnDrawGizmosSelected()
        {
            Vector3 scale = (2f * Radius) * Vector3.one;
            switch (SurfaceType)
            {
                case SurfaceTypeEnum.Plane:
                    break;
                case SurfaceTypeEnum.Cylinder:
                    Gizmos.color = Color.green;
                    Gizmos.DrawWireMesh(CylinderMesh, transform.position, transform.rotation, scale);
                    break;
                case SurfaceTypeEnum.Sphere:
                    Gizmos.color = Color.green;
                    Gizmos.DrawWireMesh(SphereMesh, transform.position, transform.rotation, scale);
                    break;
            }
        }
    }
}