Ejemplo n.º 1
0
 public ObjectDuplicationAction(List <GameObject> sourceObjects)
 {
     if (sourceObjects != null && sourceObjects.Count != 0)
     {
         _sourceParents = GameObjectExtensions.GetParentsFromObjectCollection(sourceObjects);
     }
 }
Ejemplo n.º 2
0
        public static List <ObjectSelectionBox> CalculateFromParentsToBottom(IEnumerable <GameObject> selectedObjects)
        {
            List <GameObject> parents = GameObjectExtensions.GetParentsFromObjectCollection(selectedObjects);
            var objectSelectionBoxes  = new List <ObjectSelectionBox>(20);

            foreach (var parent in parents)
            {
                Box hierarchyModelSpaceBox = parent.GetHierarchyModelSpaceBox();
                if (hierarchyModelSpaceBox.IsValid())
                {
                    objectSelectionBoxes.Add(new ObjectSelectionBox(hierarchyModelSpaceBox, parent.transform.localToWorldMatrix));
                }
            }
            return(objectSelectionBoxes);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// When the collection of controlled objects must be transformed by the gizmo, we will
        /// only apply the transformation to those objects that don't have a parent which resides
        /// inside the controlled object collection. If we don't do this, results are not very
        /// pleasing because we would apply the same transformation twice to the children: once
        /// by transforming the child itself, and a second time, by transforming its parent. This
        /// function returns a list with all the top parents (objects that don't have a parent
        /// inside the controlled object collection) that reside in the controlled object collection.
        /// </summary>
        /// <remarks>
        /// If the controlled objects collection hasn't been setup properly, the method will return
        /// an empty list of objects.
        /// </remarks>
        protected List <GameObject> GetParentsFromControlledObjects(bool filterOnlyCanBeManipulated)
        {
            // When the controlled game object collection hasn't been setup properly, return an empty list
            if (ControlledObjects == null)
            {
                return(new List <GameObject>());
            }

            if (!filterOnlyCanBeManipulated)
            {
                return(GameObjectExtensions.GetParentsFromObjectCollection(ControlledObjects));
            }
            else
            {
                List <GameObject> objectsWhichCanBeManipulated = GetControlledObjectsWhichCanBeManipulated();
                return(GameObjectExtensions.GetParentsFromObjectCollection(objectsWhichCanBeManipulated));
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Calculates and returns the object selection boxes for the specified object selection.
        /// </summary>
        /// <remarks>
        /// The method returns only those selection boxes whose model space box is set to
        /// a valid 'Bounds' instance.
        /// </remarks>
        public override List <ObjectSelectionBox> CalculateForObjectSelection(HashSet <GameObject> selectedObjects)
        {
            var objectSelectionBoxes = new List <ObjectSelectionBox>(selectedObjects.Count);

            // We will need to calculate the selection boxes for the hierarchies to which the objects belong,
            // so we will first retrieve all root objects.
            var objectRoots = GameObjectExtensions.GetRootObjectsFromObjectCollection(selectedObjects);

            // Loop through all root objects
            foreach (GameObject rootObject in objectRoots)
            {
                // Retrieve the hierarchy's model space AABB and if it is valid, create a new
                // object selection box and add it to the output list.
                Box hierarchyModelSpaceBox = rootObject.GetHierarchyModelSpaceBox();
                if (hierarchyModelSpaceBox.IsValid())
                {
                    objectSelectionBoxes.Add(new ObjectSelectionBox(hierarchyModelSpaceBox, rootObject.transform.localToWorldMatrix));
                }
            }

            return(objectSelectionBoxes);
        }
        /// <summary>
        /// Handles the game objects entered selection shape event. The method returns true if the
        /// object selection has changed after the event was handled and false otherwise.
        /// </summary>
        public override bool Handle(List <GameObject> gameObjects)
        {
            EditorObjectSelection editorObjectSelection = EditorObjectSelection.Instance;

            // We will need to select the entire hierarchy of all objects which were
            // passed as parameter. We will start by identifying the roots/top parents
            // of all those objects and store them in a hash set to easily avoid duplicates.
            var objectRoots = GameObjectExtensions.GetRootObjectsFromObjectCollection(gameObjects);

            // Now, we need to construct the final object list which will be used to perform the
            // necessary actions (i.e. select or deselect). We do this by adding the hierarchies
            // of all root objects that we identified earlier to the same object list.
            var finalObjectsList = new List <GameObject>();

            foreach (GameObject rootObject in objectRoots)
            {
                finalObjectsList.AddRange(rootObject.GetAllChildrenIncludingSelf());
            }

            // If multi-object deselection is enabled, we will deselect the game objects which were intersetced by the selection shape
            if (editorObjectSelection.MultiDeselect)
            {
                return(editorObjectSelection.DeselectGameObjectCollection(finalObjectsList));
            }
            else
            // If append is enabled, we will append the objects to the selection
            if (editorObjectSelection.AppendOrDeselectOnClick)
            {
                return(editorObjectSelection.SelectGameObjectCollection(finalObjectsList));
            }
            // If non of the above, we will clear the selection and make sure that only the specified collection of objects is selected
            else
            {
                return(editorObjectSelection.ClearAndSelectGameObjectCollection(finalObjectsList));
            }
        }