Refactor TapToPlace.cs to be more generic (#405)

* Refactor TapToPlace.cs to be more generic

* Fix formatting

* Add documentation to the README

* Add braces

* Fix potential null referencing and fix parent relative position assignment

* Move Raycast parameters to one line

* Rename placing to IsBeingDragged and make it public

* Explicitly declare camera position and direction

* Rename IsBeingDragged to IsBeingPlaced

* Reword comments for IsBeingPlaced

* Add rotation on parent when moving parent

Also some small changes:
* Remove the unused variable objectToPlace
* Add private field to keep track of parent-child relational distance
* Refactor movement code so that it only sets the position of either
the child or the parent

* Uncapitalized private data field

Author: madvlad

Assets/HoloToolkit/SpatialMapping/README.md

@@ -58,7 +58,10 @@ Generates and retrieves meshes based on spatial mapping data coming from the cur
 SpatialMappingManager.cs manages switching between source types and interacting with this class.
 
 #### TapToPlace.cs
-Simple script to add to a GameObject that allows users to tap and place the GameObject along the spatial mapping mesh.
+Simple extendable script to add to a GameObject that allows users to tap and place the GameObject along the spatial mapping mesh. 
+
+TapToPlace also allows the user to specify a parent GameObject to move along with the selected GameObject.
+
 Requires GazeManager, GestureManager, and SpatialMappingManager in the scene.
 
 ### [Scripts\RemoteMapping](Scripts/RemoteMapping)

Assets/HoloToolkit/SpatialMapping/Scripts/TapToPlace.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
+using System;
 using HoloToolkit.Unity.InputModule;
 using UnityEngine;
 
@@ -22,6 +23,18 @@ public class TapToPlace : MonoBehaviour, IInputClickHandler
         [Tooltip("Supply a friendly name for the anchor as the key name for the WorldAnchorStore.")]
         public string SavedAnchorFriendlyName = "SavedAnchorFriendlyName";
 
+        [Tooltip("Place parent on tap instead of current game object.")]
+        public bool PlaceParentOnTap = false;
+
+        [Tooltip("Specify the parent game object to be moved on tap, if the immediate parent is not desired.")]
+        public GameObject ParentGameObjectToPlace;
+
+        /// <summary>
+        /// Keeps track of if the user is moving the object or not.
+        /// Setting this to true will enable the user to move and place the object in the scene.
+        /// </summary>
+        public bool IsBeingPlaced;
+
         /// <summary>
         /// Manages persisted anchors.
         /// </summary>
@@ -34,11 +47,12 @@ public class TapToPlace : MonoBehaviour, IInputClickHandler
         private SpatialMappingManager spatialMappingManager;
 
         /// <summary>
-        /// Keeps track of if the user is moving the object or not.
+        /// Keeps track of the relative position between the parent object to be moved and
+        /// the current gameobject this script is attached to.
         /// </summary>
-        private bool placing;
+        private Vector3 parentPositionRelativeToChild;
 
-        private void Start()
+        public virtual void Start()
         {
             // Make sure we have all the components in the scene we need.
             anchorManager = WorldAnchorManager.Instance;
@@ -62,46 +76,67 @@ private void Start()
                 // If we don't have what we need to proceed, we may as well remove ourselves.
                 Destroy(this);
             }
+
+            if (PlaceParentOnTap)
+            {
+                if  (ParentGameObjectToPlace != null && !gameObject.transform.IsChildOf(ParentGameObjectToPlace.transform))
+                {
+                    Debug.LogError("The specified parent object is not a parent of this object.");
+                }
+
+                DetermineParent();
+
+                parentPositionRelativeToChild = gameObject.transform.position - ParentGameObjectToPlace.transform.position;
+            }
         }
 
-        private void Update()
+        public virtual void Update()
         {
             // If the user is in placing mode,
             // update the placement to match the user's gaze.
-            if (placing)
+            if (IsBeingPlaced)
             {
+                if (gameObject.GetComponent<TapToPlace>().IsBeingPlaced) { }
                 // Do a raycast into the world that will only hit the Spatial Mapping mesh.
-                var headPosition = Camera.main.transform.position;
-                var gazeDirection = Camera.main.transform.forward;
+                Vector3 headPosition = Camera.main.transform.position;
+                Vector3 gazeDirection = Camera.main.transform.forward;
 
                 RaycastHit hitInfo;
-                if (Physics.Raycast(headPosition, gazeDirection, out hitInfo,
-                    30.0f, spatialMappingManager.LayerMask))
+                if (Physics.Raycast(headPosition, gazeDirection, out hitInfo, 30.0f, spatialMappingManager.LayerMask))
                 {
+                    // Rotate this object to face the user.
+                    Quaternion toQuat = Camera.main.transform.localRotation;
+                    toQuat.x = 0;
+                    toQuat.z = 0;
+
                     // Move this object to where the raycast
                     // hit the Spatial Mapping mesh.
                     // Here is where you might consider adding intelligence
                     // to how the object is placed.  For example, consider
                     // placing based on the bottom of the object's
                     // collider so it sits properly on surfaces.
-                    this.transform.position = hitInfo.point;
-
-                    // Rotate this object to face the user.
-                    Quaternion toQuat = Camera.main.transform.localRotation;
-                    toQuat.x = 0;
-                    toQuat.z = 0;
-                    this.transform.rotation = toQuat;
+                    if (PlaceParentOnTap)
+                    {
+                        // Place the parent object as well but keep the focus on the current game object
+                        ParentGameObjectToPlace.transform.position = hitInfo.point - parentPositionRelativeToChild;
+                        ParentGameObjectToPlace.transform.rotation = toQuat;
+                    }
+                    else
+                    {
+                        gameObject.transform.position = hitInfo.point;
+                        gameObject.transform.rotation = toQuat;
+                    }
                 }
             }
         }
 
-        public void OnInputClicked(InputEventData eventData)
+        public virtual void OnInputClicked(InputEventData eventData)
         {
             // On each tap gesture, toggle whether the user is in placing mode.
-            placing = !placing;
+            IsBeingPlaced = !IsBeingPlaced;
 
             // If the user is in placing mode, display the spatial mapping mesh.
-            if (placing)
+            if (IsBeingPlaced)
             {
                 spatialMappingManager.DrawVisualMeshes = true;
 
@@ -117,5 +152,22 @@ public void OnInputClicked(InputEventData eventData)
                 anchorManager.AttachAnchor(gameObject, SavedAnchorFriendlyName);
             }
         }
+
+        private void DetermineParent()
+        {
+            if (ParentGameObjectToPlace == null)
+            {
+                if (gameObject.transform.parent == null)
+                {
+                    Debug.LogError("The selected GameObject has no parent.");
+                    PlaceParentOnTap = false;
+                }
+                else
+                {
+                    Debug.LogError("No parent specified. Using immediate parent instead: " + gameObject.transform.parent.gameObject.name);
+                    ParentGameObjectToPlace = gameObject.transform.parent.gameObject;
+                }
+            }
+        }
     }
 }