├── README.md
├── Scripts
    ├── Billboard.cs
    ├── Button.cs
    ├── ClearManager.cs
    ├── CursorFeedback.cs
    ├── CursorManager.cs
    ├── DirectionIndicator.cs
    ├── GazeManager.cs
    ├── GazeStabilizer.cs
    ├── GestureAction.cs
    ├── GestureManager.cs
    ├── HandsManager.cs
    ├── Interactible.cs
    ├── InteractibleManager.cs
    ├── PADManager.cs
    ├── ResetManager.cs
    ├── Singleton.cs
    ├── Source.cs
    ├── SpatialMapping.cs
    ├── TapToPlace.cs
    ├── TextManager.cs
    └── tipText.cs
└── holoROS.zip


/README.md:
--------------------------------------------------------------------------------
  1 | # holoROS
  2 | 
  3 | ROS integration with HoloLens
  4 | 
  5 | This project aimed the integration between ROS and the Microsoft augmented reality glass, HoloLens. The goal was to be able to access and obtain full control of a ROS node from HL. The chosen node was the turtlesim, a default node that mostly ROS users have access.
  6 | The idea was to build a HL application that could simulate and control the turtlesim node using HL features. HL apps are built and deployed to the device using Unity, so the environment needed to be built using this game engine. The turtlesim environment built in Unity consists in: 
  7 | 
  8 | •	A background plane that simulates the 2D blue plane where the turtle can move in ROS.
  9 | 
 10 | •	A cube that simulates the turtle.
 11 | 
 12 | •	3 buttons responsible for connecting/disconnecting, clearing and resetting.
 13 | 
 14 | •	A DPAD, an additional option for moving the turtle 
 15 | 
 16 | In this application some HL features are being used. The gesture manipulator applied on the cube is responsible for the movement. Gazing on the DPAD can also move the cube. The select gesture on the connector button is responsible for starting and finishing a ROS connection, on the reset button can take the cube to the initial position and on the clear button can clear the ROS turtle path. A select gesture can also be applied in the plane, while there is no connection with ROS, so that the user can place the turtlesim environment around the world.
 17 |  The connection between HL and ROS is made through Rosbridge. Rosbridge provides a JSON API to ROS functionality for non-ROS programs. In this project we are accessing the ROS service “teleport_absolute” to move the cube, where the turtle position in ROS is constantly updated based on the cube position in the simulated ROS environment running on HL. To clear the ROS environment, we are accessing the ROS service “clean”.
 18 | It is also possible to access ROS and move the turtle while on Unity Play mode. Press “C” to connect with ROS, move the turtle with WASD, press “E” to disconnect, “I” to return to the initial position and “R” to clear. 
 19 | Instructions
 20 | To run this project, you will need:
 21 | 
 22 | •	Unity Hololens 5.4.0b16-HTP
 23 | 
 24 | •	Linux running ROS (I am using ROS Jade running on a Ubuntu VM mounted on HyperV-Manager).
 25 | 
 26 | •	Microsoft HoloLens device or emulator
 27 | 
 28 | •	holoROS.zip folder
 29 | 
 30 | 1)	Configure and open the Unity Project:
 31 | 
 32 | •	Extract the holoROS folder.
 33 | 
 34 | •	Open Unity.
 35 | 
 36 | •	Select Open.
 37 | 
 38 | •	Select the holoROS folder you previously extracted.
 39 | 
 40 | •	Unity will open the project. There is a scene ready to go. 
 41 | 
 42 | •	Select the Scenes folder and double-click the holoConnection scene.
 43 | 
 44 | •	The scene will load.
 45 | 
 46 | •	In Unity select File > Build Settings.
 47 | 
 48 | •	Select Windows Store in the Platform list and click Switch Platform.
 49 | 
 50 | •	Set SDK to Universal 10 and Build Type to D3D.
 51 | 
 52 | •	Check Unity C# Projects.
 53 | 
 54 | •	If there isn’t any scene loaded, click Add Open Scenes to add the scene.
 55 | 
 56 | •	Close the Build Settings window.
 57 | 
 58 | •	Go to Edit > Project Settings > Player
 59 | 
 60 | •	In the “Other Settings” tab, find “Rendering” to make sure “Use 16-bit Depth Buffers” and “Virtual Reality Supported” are checked and “Windows Holographic” is added. 
 61 | 
 62 | •	In the “Publishing Settings” tab, find “Capabilities” to make sure “InternetClient”, “InternetClientServer”, “PrivateNetworkClientServer” and “SpatialPerception” are checked.
 63 | 
 64 | •	Go to Edit > Project Settings > Quality
 65 | 
 66 | •	Make sure Windows Store App level is set to Fastest.
 67 | 
 68 | 2)	ROS IP address
 69 | 
 70 | •	Before deploying your app to HoloLens or running in Unity play mode, remember to check your VM ROS IP address.
 71 | 
 72 | •	With ROS installed and running, open a terminal and type “ifconfig”. You should see and use the first provided “inet addr” on your code.
 73 | 
 74 | •	To do this, simply change the value of the “host” variable on Source.cs (Scripts folder) for the desired value. 
 75 | 
 76 | 3)	ROS Commands
 77 | 
 78 | •	With ROS installed, running and the right IP address configured you should run the following commands on ROS terminal before trying a connection: (Note: Rosbridge package need to be installed. For further information, visit: http://wiki.ros.org/rosbridge_suite)
 79 | 
 80 | •	source /opt/ros/jade/setup.bash  (Using ROS Jade)
 81 | 
 82 | •	roscore
 83 | 
 84 | •	*new terminal*
 85 | 
 86 | •	rosmake turtlesim
 87 | 
 88 | •	rosrun turtlesim turtlesim_node
 89 | 
 90 | •	*new terminal*
 91 | 
 92 | •	roslaunch rosbridge_server rosbridge_websocket.launch
 93 | 
 94 | 4)	Connecting and running on HoloLens or Unity Play Mode
 95 | 
 96 | After all the previous steps implemented you should be able to connect and access ROS from HoloLens or Unity Play Mode. Since this HL app is deployed through Unity, it is easier to test the connection in Unity Play mode before deploying it to HL, but you can directly deploy the Unity project to HL without step a).
 97 | 
 98 | a)	Connecting and running on Unity Play Mode
 99 | 
100 | •	In Unity, press the play button to enter in Unity Play Mode. You should see the rosturtle environment with a white plane, the connector, reset and clear button and the DPAD. 
101 | 
102 | •	Now, press “C” to connect. If everything works fine, you should see that the plane turned to blue, a cube appeared in the center of the plane, the connector button is now highlighted and you can see in the Rosbridge node on ROS that now we have a client connected.
103 | 
104 | •	As you use WASD you should be able to move the turtle. 
105 | 
106 | •	To clean the path left by the turtle, press “R”.
107 | 
108 | •	To return to the initial position, press “I”.
109 | 
110 | •	If you wish to disconnect from the ROS environment, press “E” or exit Unity play mode. After that, you should be able to see in the Rosbridge node on ROS that a client disconnected. 
111 | 
112 | b)	Connecting and running on HoloLens
113 | 
114 | •	In Unity select File > Build Settings. 
115 | 
116 | •	Click Build
117 | 
118 | •	In the file explorer window that appears, create a New Folder named "App".
119 | 
120 | •	Single click the App Folder.
121 | 
122 | •	Press Select Folder.
123 | 
124 | •	When Unity is done, a File Explorer window will appear.
125 | 
126 | •	Open the App folder.
127 | 
128 | •	Open (double click) holoConnection.sln.
129 | 
130 | •	Using the top toolbar in Visual Studio, change the target from Debug to Release and from ARM to X86.
131 | 
132 | •	Click on the arrow next to the Device button, and select Remote Device.
133 | 
134 | •	Set the Address to the name or IP address of your HoloLens. If you do not know your device IP address, look in Settings > Network & Internet > Advanced Options or ask Cortana "Hey Cortana, What's my IP address?"
135 | 
136 | •	Leave the Authentication Mode set to Universal.
137 | 
138 | •	Click Select
139 | 
140 | •	Click Debug > Start Without debugging or press Ctrl + F5. If this is the first time deploying to your device, you will need to pair it with Visual Studio.
141 | 
142 | •	The project will now build, deploy to your HoloLens, and then run.
143 | 
144 | •	Put on your HoloLens and look around to see your new holograms. Try to look to a “cleaner” environment so that the hologram does not appear behind a wall or other obstacle from the beginning.
145 | 
146 | •	You should see the rosturtle environment with a white plane, the connector, reset and clear button, the DPAD and virtual meshes draw around you.  
147 | 
148 | •	While we are not connected, if you perform a Select gesture in the white plane, we enter in the placing mode. You should now be able to place the rosturtle environment in a specific location by gazing at it, using the Select gesture and then moving to a new location, and using the Select gesture again. Try to place the environment in a position where none of its area gets compromised by the virtual meshes. The movement of the cube/turtle can be compromised by interferences with unwanted meshes particles. 
149 | 
150 | •	After placing the environment in a desired position, perform a select gesture in the connector button. If everything works fine, you should see that the plane turned to blue, a cube appeared in the center of the plane, the connector button is now highlighted and you can see in the Rosbridge node on ROS that now we have a client connected.
151 | 
152 | •	Now you are able to move the cube. For this, you have two options:
153 | 
154 | •	Gazing at the DPAD: Gaze at the arrows and see how the turtle moves in the hologram and ROS simultaneously, accordingly to the arrow you are gazing.
155 | 
156 | •	Gesture action:  If you gaze at the cube, four arrows should appear around the cursor to indicate that the program will now respond to Manipulation events. Lower your index finger down to your thumb, and keep them pinched together. As you move your hand around, the cube will move too, as the ROS turtle. Raise your index finger to stop manipulating the cube.
157 | 
158 | •	To clean the path left by the turtle, perform a select gesture on the clear button on the top of the plane.
159 | 
160 | •	To return to the initial position, perform a select gesture on the reset button on the top of the plane.
161 | 
162 | •	If you wish to disconnect from the ROS environment, perform another select gesture in the connector button that is now highlighted. After that, the button and the plane should return to its standard state and you should be able to see in the Rosbridge node in ROS that a client disconnected. While disconnected you can enter in placing mode and place the environment anywhere you want (as long it is in a position where none of its area gets compromised by the virtual meshes) and connect to ROS again.
163 | 
164 | Gabriel Santos Solia
165 | 
166 | Doubts? gabriel.solia@gmail.com
167 | 


--------------------------------------------------------------------------------
/Scripts/Billboard.cs:
--------------------------------------------------------------------------------
 1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
 2 | //The Billboard class implements the behaviors needed to keep the ROS environment oriented towards the user.
 3 | 
 4 | using UnityEngine;
 5 | 
 6 | namespace Scripts
 7 | {
 8 |     public enum PivotAxis
 9 |     {
10 |         // Rotate about all axes.
11 |         Free,
12 |         // Rotate about an individual axis.
13 |         X,
14 |         Y
15 |     }
16 | 
17 |     public class Billboard : MonoBehaviour
18 |     {
19 |         // The axis about which the object will rotate.
20 |         [Tooltip("Specifies the axis about which the object will rotate (Free rotates about both X and Y).")]
21 |         public PivotAxis PivotAxis = PivotAxis.Free;
22 |         
23 |         // Overrides the cached value of the GameObject's default rotation.
24 |         public Quaternion DefaultRotation { get; private set; }
25 | 
26 |         private void Awake()
27 |         {
28 |             // Cache the GameObject's default rotation.
29 |             DefaultRotation = gameObject.transform.rotation;
30 |         }
31 |         // The billboard logic is performed in FixedUpdate to update the object
32 |         // with the player independent of the frame rate.  This allows the object to 
33 |         // remain correctly rotated even if the frame rate drops.
34 |         private void FixedUpdate()
35 |         {
36 |             // Get a Vector that points from the Camera to the Target.
37 |             Vector3 directionToTarget = Camera.main.transform.position - gameObject.transform.position;
38 | 
39 |             // Adjust for the pivot axis.
40 |             switch (PivotAxis)
41 |             {
42 |                 case PivotAxis.X:
43 |                     directionToTarget.x = gameObject.transform.position.x;
44 |                     break;
45 | 
46 |                 case PivotAxis.Y:
47 |                     directionToTarget.y = gameObject.transform.position.y;
48 |                     break;
49 | 
50 |                 case PivotAxis.Free:
51 |                 default:
52 |                     break;
53 |             }
54 | 
55 |             // Calculate and apply the rotation required to reorient the object and apply the default rotation to the result.
56 |             gameObject.transform.rotation = Quaternion.LookRotation(-directionToTarget) * DefaultRotation;
57 |         }
58 |     }
59 | }


--------------------------------------------------------------------------------
/Scripts/Button.cs:
--------------------------------------------------------------------------------
 1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
 2 | //The button class controls the state of all the button used in the project.
 3 | 
 4 | using UnityEngine;
 5 | using Scripts;
 6 | using UnityEngine.Events;
 7 | 
 8 | public class Button : Singleton<Button>
 9 | {
10 |     public State StartingState;
11 | 
12 |     private Renderer buttonRenderer;
13 | 
14 |     public State currentState = State.Inactive;
15 | 
16 |     public enum State { Inactive, Active, Gazed, Selected };
17 | 
18 |     void Awake()
19 |     {
20 |         buttonRenderer = GetComponent<Renderer>();
21 | 
22 |         ChangeButtonState(StartingState);
23 |     }
24 | 
25 |     public bool IsOn()
26 |     {
27 |         return currentState != State.Inactive;
28 |     }
29 | 
30 |     public void SetActive(bool setOn)
31 |     {
32 |         if (setOn)
33 |         {
34 |             ChangeButtonState(State.Active);
35 |             if (InteractibleManager.Instance.FocusedGameObject == gameObject)
36 |             {
37 |                 ChangeButtonState(State.Gazed);
38 |             }
39 |         }
40 |         else
41 |         {
42 |             ChangeButtonState(State.Inactive);
43 |         }
44 |     }
45 | 
46 |     public void ChangeButtonState(State newState)
47 |     {
48 |         State oldState = currentState;
49 |         currentState = newState;
50 | 
51 |         if (newState > oldState)
52 |         {
53 |             for (int j = (int)newState; j > (int)oldState; j--)
54 |             {
55 |                 buttonRenderer.material.SetFloat("_BlendTex0" + j, 1.0f);
56 |             }
57 |         }
58 |         else
59 |         {
60 |             for (int j = (int)oldState; j > (int)newState; j--)
61 |             {
62 |                 buttonRenderer.material.SetFloat("_BlendTex0" + j, 0.0f);
63 |             }
64 |         }
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/Scripts/ClearManager.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | 
 4 | public class ClearManager : MonoBehaviour {
 5 | 
 6 |     public Button clearButton;
 7 | 
 8 | 	void Start () {
 9 | 	
10 | 	}
11 | 	void Update () {
12 | 
13 |         if(InteractibleManager.Instance.FocusedGameObject == gameObject && Source.Instance.con)
14 |         {
15 |             clearButton.SetActive(true);
16 |         }
17 |         else
18 |         {
19 |             clearButton.SetActive(false);
20 |         }
21 | 	
22 | 	}
23 | 
24 |     void OnSelect()
25 |     {
26 |         if(clearButton.IsOn())
27 |         {
28 |             //Accessing ROS service "clear" to clean the turlte environment on ROS.
29 |             Source.Instance.SendService("/clear", "");
30 |         }
31 | 
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/Scripts/CursorFeedback.cs:
--------------------------------------------------------------------------------
 1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
 2 | //CursorFeedback class takes GameObjects to give cursor feedback to users based on different states.
 3 | 
 4 | using Scripts;
 5 | using UnityEngine;
 6 | 
 7 | public class CursorFeedback : Singleton<CursorFeedback>
 8 | {
 9 |     public GameObject HandDetectedAsset;
10 |     private GameObject handDetectedGameObject;
11 | 
12 |     public GameObject PathingDetectedAsset;
13 |     private GameObject pathingDetectedGameObject;
14 | 
15 |     public GameObject FeedbackParent;
16 | 
17 |     private Interactible FocusedInteractible
18 |     {
19 |         get
20 |         {
21 |             if (InteractibleManager.Instance.FocusedGameObject != null)
22 |             {
23 |                 return InteractibleManager.Instance.FocusedGameObject.GetComponent<Interactible>();
24 |             }
25 | 
26 |             return null;
27 |         }
28 |     }
29 | 
30 |     void Awake()
31 |     {
32 |         if (HandDetectedAsset != null)
33 |         {
34 |             handDetectedGameObject = InstantiatePrefab(HandDetectedAsset);
35 |         }
36 | 
37 |         if (PathingDetectedAsset != null)
38 |         {
39 |             pathingDetectedGameObject = InstantiatePrefab(PathingDetectedAsset);
40 |         }
41 |     }
42 | 
43 |     private GameObject InstantiatePrefab(GameObject inputPrefab)
44 |     {
45 |         GameObject instantiatedPrefab = null;
46 | 
47 |         if (inputPrefab != null && FeedbackParent != null)
48 |         {
49 |             instantiatedPrefab = GameObject.Instantiate(inputPrefab);
50 | 
51 |             // Assign parent to be the FeedbackParent so that feedback assets move and rotate with this parent.
52 |             instantiatedPrefab.transform.parent = FeedbackParent.transform;
53 | 
54 |             // Set starting state of gameobject to be inactive.
55 |             instantiatedPrefab.gameObject.SetActive(false);
56 |         }
57 | 
58 |         return instantiatedPrefab;
59 |     }
60 | 
61 |     void Update()
62 |     {
63 |         UpdateHandDetectedState();
64 | 
65 |         UpdatePathDetectedState();
66 |     }
67 | 
68 |     private void UpdateHandDetectedState()
69 |     {
70 |         if (handDetectedGameObject == null || CursorManager.Instance == null)
71 |         {
72 |             return;
73 |         }
74 | 
75 |         handDetectedGameObject.SetActive(HandsManager.Instance.HandDetected);
76 |     }
77 | 
78 |     private void UpdatePathDetectedState()
79 |     {
80 |         if (pathingDetectedGameObject == null)
81 |         {
82 |             return;
83 |         }
84 | 
85 |         if (CursorManager.Instance == null || FocusedInteractible == null ||
86 |             GestureManager.Instance.ActiveRecognizer != GestureManager.Instance.ManipulationRecognizer)
87 |         {
88 |             pathingDetectedGameObject.SetActive(false);
89 |             return;
90 |         }
91 | 
92 |         if(InteractibleManager.Instance.FocusedGameObject.GetComponent<GestureAction>())
93 |         {
94 |             pathingDetectedGameObject.SetActive(true);
95 |         }
96 |     }
97 | }


--------------------------------------------------------------------------------
/Scripts/CursorManager.cs:
--------------------------------------------------------------------------------
 1 | //CursorManager class takes Cursor GameObjects.
 2 | // One that is on Holograms and another off Holograms.
 3 | // Shows the appropriate Cursor when a Hologram is hit.
 4 | // Places the appropriate Cursor at the hit position.
 5 | // Matches the Cursor normal to the hit surface.
 6 | 
 7 | using Scripts;
 8 | using UnityEngine;
 9 | 
10 | public class CursorManager : Singleton<CursorManager>
11 | {
12 |     public GameObject CursorOnHolograms;
13 | 
14 |     public GameObject CursorOffHolograms;
15 | 
16 |     void Awake()
17 |     {
18 |         if (CursorOnHolograms == null || CursorOffHolograms == null)
19 |         {
20 |             return;
21 |         }
22 | 
23 |         // Hide the Cursors to begin with.
24 |         CursorOnHolograms.SetActive(false);
25 |         CursorOffHolograms.SetActive(false);
26 | 
27 |         SetLayerCollisions();
28 |     }
29 | 
30 |     // This is important so our interactible objects don't collide with each other
31 |     // when we change their sizes using gestures.
32 |     private static void SetLayerCollisions()
33 |     {
34 |         int maxLayers = 31;
35 | 
36 |         // To protect apps that don't have an Interactible layer in their project.
37 |         int interactibleLayer = LayerMask.NameToLayer("Interactible");
38 | 
39 |         if (interactibleLayer < 0 || interactibleLayer > maxLayers)
40 |         {
41 |             return;
42 |         }
43 | 
44 |         // Ignore all collisions with UI except for Cursor collisions.
45 |         // Unity has 31 possible layers.  There is no way to get this value in code.
46 |         for (int i = 0; i < maxLayers; i++)
47 |         {
48 |             // Ensure the Interactible objects do not collide with other layers.
49 |             Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Interactible"), i, true);
50 |         }
51 | 
52 |         // Ensures the Cursor can collide with the Interactible objects only.
53 |         Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Interactible"), LayerMask.NameToLayer("Cursor"), false);
54 |     }
55 | 
56 |     void Update()
57 |     {
58 |         if (GazeManager.Instance == null || CursorOnHolograms == null || CursorOffHolograms == null)
59 |         {
60 |             return;
61 |         }
62 | 
63 |         if (GazeManager.Instance.Hit && InteractibleManager.Instance.isSelected)
64 |         {
65 |             CursorOnHolograms.SetActive(true);
66 |             CursorOffHolograms.SetActive(false);
67 |         }
68 |         else
69 |         {
70 |             CursorOffHolograms.SetActive(true);
71 |             CursorOnHolograms.SetActive(false);
72 |         }
73 | 
74 |         // Place the cursor at the calculated position.
75 |         gameObject.transform.position = GazeManager.Instance.Position;
76 | 
77 |         // Reorient the cursors to match the hit object normal.
78 |         CursorOnHolograms.transform.parent.transform.up = GazeManager.Instance.Normal;
79 |     }
80 | }


--------------------------------------------------------------------------------
/Scripts/DirectionIndicator.cs:
--------------------------------------------------------------------------------
  1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
  2 | //DirectionIndicator creates an indicator around the cursor showing what direction to turn to find the ROS environment.
  3 | 
  4 | using UnityEngine;
  5 | 
  6 | namespace Scripts
  7 | {
  8 |     public class DirectionIndicator : MonoBehaviour
  9 |     {
 10 |         public GameObject Cursor;
 11 | 
 12 |         public GameObject DirectionIndicatorObject;
 13 | 
 14 |         public Color DirectionIndicatorColor = Color.blue;
 15 |         
 16 |         public float TitleSafeFactor = 0.1f;
 17 | 
 18 |         // The default rotation of the cursor direction indicator.
 19 |         private Quaternion directionIndicatorDefaultRotation = Quaternion.identity;
 20 | 
 21 |         // Cache the MeshRenderer for the on-cursor indicator since it will be enabled and disabled frequently.
 22 |         private MeshRenderer directionIndicatorRenderer;
 23 | 
 24 |         // Check if the cursor direction indicator is visible.
 25 |         private bool isDirectionIndicatorVisible;
 26 | 
 27 |         public void Awake()
 28 |         {
 29 |             if (DirectionIndicatorObject == null)
 30 |             {
 31 |                 return;
 32 |             }
 33 | 
 34 |             // Instantiate the direction indicator.
 35 |             DirectionIndicatorObject = InstantiateDirectionIndicator(DirectionIndicatorObject);
 36 |             directionIndicatorDefaultRotation = DirectionIndicatorObject.transform.rotation;
 37 | 
 38 |             directionIndicatorRenderer = DirectionIndicatorObject.GetComponent<MeshRenderer>();
 39 |         }
 40 | 
 41 |         public void OnDestroy()
 42 |         {
 43 |             GameObject.Destroy(DirectionIndicatorObject);
 44 |         }
 45 | 
 46 |         private GameObject InstantiateDirectionIndicator(GameObject directionIndicator)
 47 |         {
 48 |             GameObject indicator = Instantiate(directionIndicator);
 49 | 
 50 |             MeshRenderer indicatorRenderer = indicator.GetComponent<MeshRenderer>();
 51 | 
 52 |             if (indicatorRenderer == null)
 53 |             {
 54 |                 // The Direction Indicator must have a MeshRenderer so it can give visual feedback to the user which way to look.
 55 |                 // Add one if there wasn't one.
 56 |                 indicatorRenderer = indicator.AddComponent<MeshRenderer>();
 57 |             }
 58 | 
 59 |             // Start with the indicator disabled.
 60 |             indicatorRenderer.enabled = false;
 61 | 
 62 |             // Remove any colliders and rigidbodies so the indicators do not interfere with Unity's physics system.
 63 |             foreach (Collider collider in indicator.GetComponents<Collider>())
 64 |             {
 65 |                 Destroy(collider);
 66 |             }
 67 | 
 68 |             foreach (Rigidbody rigidBody in indicator.GetComponents<Rigidbody>())
 69 |             {
 70 |                 Destroy(rigidBody);
 71 |             }
 72 | 
 73 |             Material indicatorMaterial = indicatorRenderer.material;
 74 |             indicatorMaterial.color = DirectionIndicatorColor;
 75 |             indicatorMaterial.SetColor("_TintColor", DirectionIndicatorColor);
 76 | 
 77 |             // Make this indicator a child of the targeted GameObject.
 78 |             indicator.transform.SetParent(gameObject.transform);
 79 | 
 80 |             return indicator;
 81 |         }
 82 | 
 83 |         public void Update()
 84 |         {
 85 |             if (DirectionIndicatorObject == null)
 86 |             {
 87 |                 return;
 88 |             }
 89 | 
 90 |             // Direction from the Main Camera to this script's parent gameObject.
 91 |             Vector3 camToObjectDirection = gameObject.transform.position - Camera.main.transform.position;
 92 |             camToObjectDirection.Normalize();
 93 | 
 94 |             // The cursor indicator should only be visible if the target is not visible.
 95 |             isDirectionIndicatorVisible = !IsTargetVisible();
 96 |             directionIndicatorRenderer.enabled = isDirectionIndicatorVisible;
 97 | 
 98 |             if (isDirectionIndicatorVisible)
 99 |             {
100 |                 Vector3 position;
101 |                 Quaternion rotation;
102 |                 GetDirectionIndicatorPositionAndRotation(
103 |                     camToObjectDirection,
104 |                     out position,
105 |                     out rotation);
106 | 
107 |                 DirectionIndicatorObject.transform.position = position;
108 |                 DirectionIndicatorObject.transform.rotation = rotation;
109 |             }
110 |         }
111 | 
112 |         private bool IsTargetVisible()
113 |         {
114 |             // This will return true if the target's mesh is within the Main Camera's view frustums.
115 |             Vector3 targetViewportPosition = Camera.main.WorldToViewportPoint(gameObject.transform.position);
116 |             return (targetViewportPosition.x > TitleSafeFactor && targetViewportPosition.x < 1 - TitleSafeFactor &&
117 |                 targetViewportPosition.y > TitleSafeFactor && targetViewportPosition.y < 1 - TitleSafeFactor &&
118 |                 targetViewportPosition.z > 0);
119 |         }
120 | 
121 |         private void GetDirectionIndicatorPositionAndRotation(
122 |             Vector3 camToObjectDirection,
123 |             out Vector3 position,
124 |             out Quaternion rotation)
125 |         {
126 |             // Find position:
127 |             // Use this value to decrease the distance from the cursor center an object is rendered to keep it in view.
128 |             float metersFromCursor = 0.3f;
129 | 
130 |             // Save the cursor transform position in a variable.
131 |             Vector3 origin = Cursor.transform.position;
132 | 
133 |             // Project the camera to target direction onto the screen plane.
134 |             Vector3 cursorIndicatorDirection = Vector3.ProjectOnPlane(camToObjectDirection, -1 * Camera.main.transform.forward);
135 |             cursorIndicatorDirection.Normalize();
136 | 
137 |             // If the direction is 0, set the direction to the right.
138 |             // This will only happen if the camera is facing directly away from the target.
139 |             if (cursorIndicatorDirection == Vector3.zero)
140 |             {
141 |                 cursorIndicatorDirection = Camera.main.transform.right;
142 |             }
143 | 
144 |             // The final position is translated from the center of the screen along this direction vector.
145 |             position = origin + cursorIndicatorDirection * metersFromCursor;
146 | 
147 |             // Find the rotation from the facing direction to the target object.
148 |             rotation = Quaternion.LookRotation(
149 |                 Camera.main.transform.forward,
150 |                 cursorIndicatorDirection) * directionIndicatorDefaultRotation;
151 |         }
152 |     }
153 | }
154 | 


--------------------------------------------------------------------------------
/Scripts/GazeManager.cs:
--------------------------------------------------------------------------------
  1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
  2 | // GazeManager determines the location of the user's gaze, hit position and normals.
  3 | 
  4 | using Scripts;
  5 | using UnityEngine;
  6 | public class GazeManager : Singleton<GazeManager>
  7 | {
  8 |     [Tooltip("Maximum gaze distance for calculating a hit.")]
  9 |     public float MaxGazeDistance = 5.0f;
 10 | 
 11 |     [Tooltip("Select the layers raycast should target.")]
 12 |     public LayerMask RaycastLayerMask = Physics.DefaultRaycastLayers;
 13 | 
 14 |     /// <summary>
 15 |     /// Physics.Raycast result is true if it hits a Hologram.
 16 |     /// </summary>
 17 |     public bool Hit { get; private set; }
 18 | 
 19 |     /// <summary>
 20 |     /// HitInfo property gives access
 21 |     /// to RaycastHit public members.
 22 |     /// </summary>
 23 |     public RaycastHit HitInfo { get; private set; }
 24 | 
 25 |     /// <summary>
 26 |     /// Position of the user's gaze.
 27 |     /// </summary>
 28 |     public Vector3 Position { get; private set; }
 29 | 
 30 |     /// <summary>
 31 |     /// RaycastHit Normal direction.
 32 |     /// </summary>
 33 |     public Vector3 Normal { get; private set; }
 34 | 
 35 |     private GazeStabilizer gazeStabilizer;
 36 |     private Vector3 gazeOrigin;
 37 |     private Vector3 gazeDirection;
 38 | 
 39 |     void Awake()
 40 |     {
 41 |         // GetComponent GazeStabilizer and assign it to gazeStabilizer.
 42 |         gazeStabilizer = GetComponent<GazeStabilizer>();
 43 |     }
 44 | 
 45 |     private void Update()
 46 |     {
 47 |         //Assign Camera's main transform position to gazeOrigin.
 48 |         gazeOrigin = Camera.main.transform.position;
 49 | 
 50 |         //Assign Camera's main transform forward to gazeDirection.
 51 |         gazeDirection = Camera.main.transform.forward;
 52 | 
 53 |         // Using gazeStabilizer, call function UpdateHeadStability.
 54 |         // Pass in gazeOrigin and Camera's main transform rotation.
 55 |         gazeStabilizer.UpdateHeadStability(gazeOrigin, Camera.main.transform.rotation);
 56 | 
 57 |         // Using gazeStabilizer, get the StableHeadPosition and
 58 |         // assign it to gazeOrigin.
 59 |         gazeOrigin = gazeStabilizer.StableHeadPosition;
 60 | 
 61 |         UpdateRaycast();
 62 |     }
 63 | 
 64 |     /// <summary>
 65 |     /// Calculates the Raycast hit position and normal.
 66 |     /// </summary>
 67 |     private void UpdateRaycast()
 68 |     {
 69 |         // Create a variable hitInfo of type RaycastHit.
 70 |         RaycastHit hitInfo;
 71 | 
 72 |         // Perform a Unity Physics Raycast.
 73 |         // Collect return value in public property Hit.
 74 |         // Pass in origin as gazeOrigin and direction as gazeDirection.
 75 |         // Collect the information in hitInfo.
 76 |         // Pass in MaxGazeDistance and RaycastLayerMask.
 77 |         Hit = Physics.Raycast(gazeOrigin,
 78 |                        gazeDirection,
 79 |                        out hitInfo,
 80 |                        MaxGazeDistance,
 81 |                        RaycastLayerMask);
 82 | 
 83 |         // Assign hitInfo variable to the HitInfo public property 
 84 |         // so other classes can access it.
 85 |         HitInfo = hitInfo;
 86 | 
 87 |         if (Hit)
 88 |         {
 89 |             // If raycast hit a hologram...
 90 | 
 91 |             // Assign property Position to be the hitInfo point.
 92 |             Position = hitInfo.point;
 93 |             // Assign property Normal to be the hitInfo normal.
 94 |             Normal = hitInfo.normal;
 95 |         }
 96 |         else
 97 |         {
 98 |             // If raycast did not hit a hologram...
 99 |             // Save defaults ...
100 | 
101 |             // Assign Position to be gazeOrigin plus MaxGazeDistance times gazeDirection.
102 |             Position = gazeOrigin + (gazeDirection * MaxGazeDistance);
103 |             // Assign Normal to be the user's gazeDirection.
104 |             Normal = gazeDirection;
105 |         }
106 |     }
107 | }


--------------------------------------------------------------------------------
/Scripts/GazeStabilizer.cs:
--------------------------------------------------------------------------------
  1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
  2 | 
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using UnityEngine;
  6 | 
  7 | namespace Scripts
  8 | {
  9 |     /// <summary>
 10 |     /// GazeStabilizer iterates over samples of Raycast data and
 11 |     /// helps stabilize the user's gaze for precision targeting.
 12 |     /// </summary>
 13 |     public class GazeStabilizer : MonoBehaviour
 14 |     {
 15 |         [Tooltip("Number of samples that you want to iterate on.")]
 16 |         [Range(1, 120)]
 17 |         public int StoredStabilitySamples = 60;
 18 | 
 19 |         [Tooltip("Position based distance away from gravity well.")]
 20 |         public float PositionDropOffRadius = 0.02f;
 21 | 
 22 |         [Tooltip("Direction based distance away from gravity well.")]
 23 |         public float DirectionDropOffRadius = 0.1f;
 24 | 
 25 |         [Tooltip("Position lerp interpolation factor.")]
 26 |         [Range(0.25f, 0.85f)]
 27 |         public float PositionStrength = 0.66f;
 28 | 
 29 |         [Tooltip("Direction lerp interpolation factor.")]
 30 |         [Range(0.25f, 0.85f)]
 31 |         public float DirectionStrength = 0.83f;
 32 | 
 33 |         [Tooltip("Stability average weight multiplier factor.")]
 34 |         public float StabilityAverageDistanceWeight = 2.0f;
 35 | 
 36 |         [Tooltip("Stability variance weight multiplier factor.")]
 37 |         public float StabilityVarianceWeight = 1.0f;
 38 | 
 39 |         // Access the below public properties from the client class to consume stable values.
 40 |         public Vector3 StableHeadPosition { get; private set; }
 41 |         public Quaternion StableHeadRotation { get; private set; }
 42 |         public Ray StableHeadRay { get; private set; }
 43 | 
 44 |         public struct GazeSample
 45 |         {
 46 |             public Vector3 position;
 47 |             public Vector3 direction;
 48 |             public float timestamp;
 49 |         };
 50 | 
 51 |         private Queue<GazeSample> stabilitySamples = new Queue<GazeSample>();
 52 | 
 53 |         private Vector3 gazePosition;
 54 |         private Vector3 gazeDirection;
 55 | 
 56 |         // Most recent calculated instability values.
 57 |         private float gazePositionInstability;
 58 |         private float gazeDirectionInstability;
 59 | 
 60 |         private bool gravityPointExists = false;
 61 |         private Vector3 gravityWellPosition;
 62 |         private Vector3 gravityWellDirection;
 63 | 
 64 |         // Transforms instability value into a modified drop off distance, modify with caution.
 65 |         private const float positionDestabilizationFactor = 0.02f;
 66 |         private const float directionDestabilizationFactor = 0.3f;
 67 | 
 68 |         /// <summary>
 69 |         /// Updates the StableHeadPosition and StableHeadRotation based on GazeSample values.
 70 |         /// Call this method with RaycastHit parameters to get stable values.
 71 |         /// </summary>
 72 |         /// <param name="position">Position value from a RaycastHit point.</param>
 73 |         /// <param name="rotation">Rotation value from a RaycastHit rotation.</param>
 74 |         public void UpdateHeadStability(Vector3 position, Quaternion rotation)
 75 |         {
 76 |             gazePosition = position;
 77 |             gazeDirection = rotation * Vector3.forward;
 78 | 
 79 |             AddGazeSample(gazePosition, gazeDirection);
 80 | 
 81 |             UpdateInstability(out gazePositionInstability, out gazeDirectionInstability);
 82 | 
 83 |             // If we don't have a gravity point, just use the gaze position.
 84 |             if (!gravityPointExists)
 85 |             {
 86 |                 gravityWellPosition = gazePosition;
 87 |                 gravityWellDirection = gazeDirection;
 88 |                 gravityPointExists = true;
 89 |             }
 90 | 
 91 |             UpdateGravityWellPositionDirection();
 92 |         }
 93 | 
 94 |         private void AddGazeSample(Vector3 positionSample, Vector3 directionSample)
 95 |         {
 96 |             // Record and save sample data.
 97 |             GazeSample newStabilitySample;
 98 |             newStabilitySample.position = positionSample;
 99 |             newStabilitySample.direction = directionSample;
100 |             newStabilitySample.timestamp = Time.time;
101 | 
102 |             if (stabilitySamples != null)
103 |             {
104 |                 // Remove from front if we exceed stored samples.
105 |                 if (stabilitySamples.Count >= StoredStabilitySamples)
106 |                 {
107 |                     stabilitySamples.Dequeue();
108 |                 }
109 | 
110 |                 stabilitySamples.Enqueue(newStabilitySample);
111 |             }
112 |         }
113 | 
114 |         private void UpdateInstability(out float positionInstability, out float directionInstability)
115 |         {
116 |             GazeSample mostRecentSample;
117 | 
118 |             float positionDeltaMin = 0.0f;
119 |             float positionDeltaMax = 0.0f;
120 |             float positionDeltaMean = 0.0f;
121 | 
122 |             float directionDeltaMin = 0.0f;
123 |             float directionDeltaMax = 0.0f;
124 |             float directionDeltaMean = 0.0f;
125 | 
126 |             float positionDelta = 0.0f;
127 |             float directionDelta = 0.0f;
128 | 
129 |             positionInstability = 0.0f;
130 |             directionInstability = 0.0f;
131 | 
132 |             // If we have zero or one sample, there is no instability to report.
133 |             if (stabilitySamples.Count < 2)
134 |             {
135 |                 return;
136 |             }
137 | 
138 |             mostRecentSample = stabilitySamples.ElementAt(stabilitySamples.Count - 1);
139 | 
140 |             // All but most recent.
141 |             for (int i = 0; i < stabilitySamples.Count - 1; ++i)
142 |             {
143 |                 // Calculate difference between current sample and most recent sample.
144 |                 positionDelta = Vector3.Magnitude(stabilitySamples.ElementAt(i).position - mostRecentSample.position);
145 | 
146 |                 directionDelta = Vector3.Angle(stabilitySamples.ElementAt(i).direction, mostRecentSample.direction) * Mathf.Deg2Rad;
147 | 
148 |                 // Initialize max and min on first sample.
149 |                 if (i == 0)
150 |                 {
151 |                     positionDeltaMin = positionDelta;
152 |                     positionDeltaMax = positionDelta;
153 |                     directionDeltaMin = directionDelta;
154 |                     directionDeltaMax = directionDelta;
155 |                 }
156 |                 else
157 |                 {
158 |                     // Update maximum, minimum and mean differences from most recent sample.
159 |                     positionDeltaMin = Mathf.Min(positionDelta, positionDeltaMin);
160 |                     positionDeltaMax = Mathf.Max(positionDelta, positionDeltaMax);
161 | 
162 |                     directionDeltaMin = Mathf.Min(directionDelta, directionDeltaMin);
163 |                     directionDeltaMax = Mathf.Max(directionDelta, directionDeltaMax);
164 |                 }
165 | 
166 |                 positionDeltaMean += positionDelta;
167 |                 directionDeltaMean += directionDelta;
168 |             }
169 | 
170 |             positionDeltaMean = positionDeltaMean / (stabilitySamples.Count - 1);
171 |             directionDeltaMean = directionDeltaMean / (stabilitySamples.Count - 1);
172 | 
173 |             // Calculate stability value for Gaze position and direction.  Note that stability values will be significantly different for position and
174 |             // direction since the position value is based on values in meters while the direction stability is based on data in radians.
175 |             positionInstability = StabilityVarianceWeight * (positionDeltaMax - positionDeltaMin) + StabilityAverageDistanceWeight * positionDeltaMean;
176 |             directionInstability = StabilityVarianceWeight * (directionDeltaMax - directionDeltaMin) + StabilityAverageDistanceWeight * directionDeltaMean;
177 |         }
178 | 
179 |         private void UpdateGravityWellPositionDirection()
180 |         {
181 |             float stabilityModifiedPositionDropOffDistance;
182 |             float stabilityModifiedDirectionDropOffDistance;
183 |             float normalizedGazeToGravityWellPosition;
184 |             float normalizedGazeToGravityWellDirection;
185 | 
186 |             // Modify effective size of well based on gaze stability.
187 |             stabilityModifiedPositionDropOffDistance = Mathf.Max(0.0f, PositionDropOffRadius - (gazePositionInstability * positionDestabilizationFactor));
188 |             stabilityModifiedDirectionDropOffDistance = Mathf.Max(0.0f, DirectionDropOffRadius - (gazeDirectionInstability * directionDestabilizationFactor));
189 | 
190 |             // Determine how far away from the well the gaze is, if that distance is zero push the normalized value above 1.0 to
191 |             // force a gravity well position update.
192 |             normalizedGazeToGravityWellPosition = 2.0f;
193 |             if (stabilityModifiedPositionDropOffDistance > 0.0f)
194 |             {
195 |                 normalizedGazeToGravityWellPosition = Vector3.Magnitude(gravityWellPosition - gazePosition) / stabilityModifiedPositionDropOffDistance;
196 |             }
197 | 
198 |             normalizedGazeToGravityWellDirection = 2.0f;
199 |             if (stabilityModifiedDirectionDropOffDistance > 0.0f)
200 |             {
201 |                 normalizedGazeToGravityWellDirection = Mathf.Acos(Vector3.Dot(gravityWellDirection, gazeDirection)) / stabilityModifiedDirectionDropOffDistance;
202 |             }
203 | 
204 |             // Move gravity well with Gaze if necessary.
205 |             if (normalizedGazeToGravityWellPosition > 1.0f)
206 |             {
207 |                 gravityWellPosition = gazePosition - Vector3.Normalize(gazePosition - gravityWellPosition) * stabilityModifiedPositionDropOffDistance;
208 |             }
209 | 
210 |             if (normalizedGazeToGravityWellDirection > 1.0f)
211 |             {
212 |                 gravityWellDirection = Vector3.Normalize(gazeDirection - Vector3.Normalize(gazeDirection - gravityWellDirection) * stabilityModifiedDirectionDropOffDistance);
213 |             }
214 | 
215 |             // Adjust direction and position towards gravity well based on configurable strengths.
216 |             StableHeadPosition = Vector3.Lerp(gazePosition, gravityWellPosition, PositionStrength);
217 |             StableHeadRotation = Quaternion.LookRotation(Vector3.Lerp(gazeDirection, gravityWellDirection, DirectionStrength));
218 |             StableHeadRay = new Ray(StableHeadPosition, StableHeadRotation * Vector3.forward);
219 |         }
220 |     }
221 | }
222 | 


--------------------------------------------------------------------------------
/Scripts/GestureAction.cs:
--------------------------------------------------------------------------------
 1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
 2 | 
 3 | using UnityEngine;
 4 | using System.Collections;
 5 | 
 6 | public class GestureAction : MonoBehaviour
 7 | {
 8 |     private Vector3 manipulationPreviousPosition;
 9 | 
10 |     // Use this for initialization
11 | 
12 |     void Start()
13 |     {
14 |         GestureManager.Instance.Transition(GestureManager.Instance.ManipulationRecognizer);
15 |     }
16 | 
17 |     // Update is called once per frame
18 |     void Update()
19 |     {
20 |         //Updating cube position respecting the plane boundaries.
21 |         Vector3 pos = transform.localPosition;
22 |         pos.x = Mathf.Clamp(pos.x, - 0.46f, 0.46f);
23 |         pos.y = Mathf.Clamp(pos.y, - 0.46f, + 0.46f);
24 |         pos.z = - 0.7f;
25 | 
26 |         transform.localPosition = pos;
27 |     }
28 | 
29 |     void PerformManipulationStart(Vector3 position)
30 |     {
31 |         manipulationPreviousPosition = position;
32 |     }
33 | 
34 |     void PerformManipulationUpdate(Vector3 position)
35 |     {
36 |         if (GestureManager.Instance.IsManipulating)
37 |         {
38 |             Vector3 moveVector = Vector3.zero;
39 | 
40 |             // Calculate the moveVector as position - manipulationPreviousPosition.
41 |             moveVector = position - manipulationPreviousPosition;
42 | 
43 |             //Update the manipulationPreviousPosition with the current position.
44 |             manipulationPreviousPosition = position;
45 | 
46 |             //Increment this transform's position by the moveVector.
47 |             transform.position += moveVector;
48 |             
49 |         }
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/Scripts/GestureManager.cs:
--------------------------------------------------------------------------------
  1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
  2 | 
  3 | using Scripts;
  4 | using UnityEngine;
  5 | using UnityEngine.VR.WSA.Input;
  6 | 
  7 | public class GestureManager : Singleton<GestureManager>
  8 | {
  9 |     public GestureRecognizer HoverRecognizer { get; private set; }
 10 | 
 11 |     public GestureRecognizer ManipulationRecognizer { get; private set; }
 12 | 
 13 |     public bool IsManipulating { get; private set; }
 14 | 
 15 |     public Vector3 ManipulationPosition { get; private set; }
 16 | 
 17 |     public GestureRecognizer ActiveRecognizer { get; private set; }
 18 | 
 19 |     void Awake()
 20 |     {
 21 |         HoverRecognizer = new GestureRecognizer();
 22 |         HoverRecognizer.TappedEvent += (source, tapCount, ray) =>
 23 |         {
 24 |             if (InteractibleManager.Instance.FocusedGameObject != null)
 25 |             {
 26 |                 InteractibleManager.Instance.FocusedGameObject.SendMessageUpwards("OnSelect");
 27 |             }
 28 |         };
 29 |         HoverRecognizer.StartCapturingGestures();
 30 | 
 31 |         // Instantiate the ManipulationRecognizer.
 32 |         ManipulationRecognizer = new GestureRecognizer();
 33 | 
 34 |         // Add the ManipulationTranslate GestureSetting to the ManipulationRecognizer's RecognizableGestures.
 35 |         ManipulationRecognizer.SetRecognizableGestures(GestureSettings.ManipulationTranslate);
 36 | 
 37 |         // Register for the Manipulation events on the ManipulationRecognizer.
 38 |         ManipulationRecognizer.ManipulationStartedEvent += ManipulationRecognizer_ManipulationStartedEvent;
 39 |         ManipulationRecognizer.ManipulationUpdatedEvent += ManipulationRecognizer_ManipulationUpdatedEvent;
 40 |         ManipulationRecognizer.ManipulationCompletedEvent += ManipulationRecognizer_ManipulationCompletedEvent;
 41 |         ManipulationRecognizer.ManipulationCanceledEvent += ManipulationRecognizer_ManipulationCanceledEvent;
 42 | 
 43 |         ResetGestureRecognizers();
 44 |     }
 45 | 
 46 |     void OnDestroy()
 47 |     {
 48 | 
 49 |         // Unregister the Manipulation events on the ManipulationRecognizer.
 50 |         ManipulationRecognizer.ManipulationStartedEvent -= ManipulationRecognizer_ManipulationStartedEvent;
 51 |         ManipulationRecognizer.ManipulationUpdatedEvent -= ManipulationRecognizer_ManipulationUpdatedEvent;
 52 |         ManipulationRecognizer.ManipulationCompletedEvent -= ManipulationRecognizer_ManipulationCompletedEvent;
 53 |         ManipulationRecognizer.ManipulationCanceledEvent -= ManipulationRecognizer_ManipulationCanceledEvent;
 54 |     }
 55 | 
 56 |     /// <summary>
 57 |     /// Revert back to the default GestureRecognizer.
 58 |     /// </summary>
 59 |     public void ResetGestureRecognizers()
 60 |     {
 61 |         // Default to the navigation gestures.
 62 |         Transition(null);
 63 |     }
 64 | 
 65 |     /// <summary>
 66 |     /// Transition to a new GestureRecognizer.
 67 |     /// </summary>
 68 |     /// <param name="newRecognizer">The GestureRecognizer to transition to.</param>
 69 |     public void Transition(GestureRecognizer newRecognizer)
 70 |     {
 71 |         if (newRecognizer == null)
 72 |         {
 73 |             return;
 74 |         }
 75 | 
 76 |         if (ActiveRecognizer != null)
 77 |         {
 78 |             if (ActiveRecognizer == newRecognizer)
 79 |             {
 80 |                 return;
 81 |             }
 82 | 
 83 |             ActiveRecognizer.CancelGestures();
 84 |             ActiveRecognizer.StopCapturingGestures();
 85 |         }
 86 | 
 87 |         newRecognizer.StartCapturingGestures();
 88 |         ActiveRecognizer = newRecognizer;
 89 |     }
 90 | 
 91 |     private void ManipulationRecognizer_ManipulationStartedEvent(InteractionSourceKind source, Vector3 position, Ray ray)
 92 |     {
 93 |         if (HandsManager.Instance.FocusedGameObject != null)
 94 |         {
 95 |             IsManipulating = true;
 96 | 
 97 |             ManipulationPosition = position;
 98 | 
 99 |             HandsManager.Instance.FocusedGameObject.SendMessageUpwards("PerformManipulationStart", position);
100 |         }
101 |     }
102 | 
103 |     private void ManipulationRecognizer_ManipulationUpdatedEvent(InteractionSourceKind source, Vector3 position, Ray ray)
104 |     {
105 |         if (HandsManager.Instance.FocusedGameObject != null)
106 |         {
107 |             IsManipulating = true;
108 | 
109 |             ManipulationPosition = position;
110 | 
111 |             HandsManager.Instance.FocusedGameObject.SendMessageUpwards("PerformManipulationUpdate", position);
112 |         }
113 |     }
114 | 
115 |     private void ManipulationRecognizer_ManipulationCompletedEvent(InteractionSourceKind source, Vector3 position, Ray ray)
116 |     {
117 |         IsManipulating = false;
118 |     }
119 | 
120 |     private void ManipulationRecognizer_ManipulationCanceledEvent(InteractionSourceKind source, Vector3 position, Ray ray)
121 |     {
122 |         IsManipulating = false;
123 |     }
124 | }
125 | 


--------------------------------------------------------------------------------
/Scripts/HandsManager.cs:
--------------------------------------------------------------------------------
 1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
 2 | 
 3 | using Scripts;
 4 | using UnityEngine.VR.WSA.Input;
 5 | using UnityEngine;
 6 | 
 7 | /// <summary>
 8 | /// HandsManager keeps track of when a hand is detected.
 9 | /// </summary>
10 | public class HandsManager : Singleton<HandsManager>
11 | {
12 |     /// <summary>
13 |     /// Tracks the hand detected state.
14 |     /// </summary>
15 |     public bool HandDetected
16 |     {
17 |         get;
18 |         private set;
19 |     }
20 | 
21 |     // Keeps track of the GameObject that the hand is interacting with.
22 |     public GameObject FocusedGameObject { get; private set; }
23 | 
24 |     void Awake()
25 |     {
26 |         InteractionManager.SourceDetected += InteractionManager_SourceDetected;
27 |         InteractionManager.SourceLost += InteractionManager_SourceLost;
28 | 
29 |         //Register for SourceManager.SourcePressed event.
30 |         InteractionManager.SourcePressed += InteractionManager_SourcePressed;
31 | 
32 |         //Register for SourceManager.SourceReleased event.
33 |         InteractionManager.SourceReleased += InteractionManager_SourceReleased;
34 | 
35 |         //Initialize FocusedGameObject as null.
36 |         FocusedGameObject = null;
37 |     }
38 | 
39 |     private void InteractionManager_SourceDetected(InteractionSourceState hand)
40 |     {
41 |         HandDetected = true;
42 |     }
43 | 
44 |     private void InteractionManager_SourceLost(InteractionSourceState hand)
45 |     {
46 |         HandDetected = false;
47 | 
48 |         //Reset FocusedGameObject.
49 |         ResetFocusedGameObject();
50 |     }
51 | 
52 |     private void InteractionManager_SourcePressed(InteractionSourceState hand)
53 |     {
54 |         if (InteractibleManager.Instance.FocusedGameObject != null)
55 |         {
56 |             //Cache InteractibleManager's FocusedGameObject in FocusedGameObject.
57 |             FocusedGameObject = InteractibleManager.Instance.FocusedGameObject;
58 |         }
59 |     }
60 | 
61 |     private void InteractionManager_SourceReleased(InteractionSourceState hand)
62 |     {
63 |         //Reset FocusedGameObject.
64 |         ResetFocusedGameObject();
65 |     }
66 | 
67 |     private void ResetFocusedGameObject()
68 |     {
69 |         // Set FocusedGameObject to be null.
70 |         FocusedGameObject = null;
71 | 
72 |         // On GestureManager call ResetGestureRecognizers
73 |         // to complete any currently active gestures.
74 |         GestureManager.Instance.ResetGestureRecognizers();
75 |     }
76 | 
77 |     void OnDestroy()
78 |     {
79 |         InteractionManager.SourceDetected -= InteractionManager_SourceDetected;
80 |         InteractionManager.SourceLost -= InteractionManager_SourceLost;
81 | 
82 |         // Unregister the SourceManager.SourceReleased event.
83 |         InteractionManager.SourceReleased -= InteractionManager_SourceReleased;
84 | 
85 |         // Unregister for SourceManager.SourcePressed event.
86 |         InteractionManager.SourcePressed -= InteractionManager_SourcePressed;
87 |     }
88 | }


--------------------------------------------------------------------------------
/Scripts/Interactible.cs:
--------------------------------------------------------------------------------
 1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
 2 | 
 3 | using UnityEngine;
 4 | 
 5 | /// <summary>
 6 | /// The Interactible class flags a Game Object as being "Interactible".
 7 | /// Determines what happens when an Interactible is being gazed at.
 8 | /// </summary>
 9 | public class Interactible : MonoBehaviour
10 | {
11 |     private Material[] defaultMaterials;
12 | 
13 |     void Start()
14 |     {
15 |         defaultMaterials = GetComponent<Renderer>().materials;
16 | 
17 |         // Add a BoxCollider if the interactible does not contain one.
18 |         Collider collider = GetComponentInChildren<Collider>();
19 |         if (collider == null)
20 |         {
21 |             gameObject.AddComponent<BoxCollider>();
22 |         }
23 |     }
24 | }


--------------------------------------------------------------------------------
/Scripts/InteractibleManager.cs:
--------------------------------------------------------------------------------
 1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
 2 | 
 3 | using Scripts;
 4 | using UnityEngine;
 5 | 
 6 | /// <summary>
 7 | /// InteractibleManager keeps tracks of which GameObject
 8 | /// is currently in focus.
 9 | /// </summary>
10 | public class InteractibleManager : Singleton<InteractibleManager>
11 | {
12 |     public GameObject FocusedGameObject { get; private set; }
13 | 
14 |     private GameObject oldFocusedGameObject = null;
15 | 
16 |     public bool isSelected;
17 |     void Start()
18 |     {
19 |         FocusedGameObject = null;
20 |     }
21 | 
22 |     void Update()
23 |     {
24 |         oldFocusedGameObject = FocusedGameObject;
25 | 
26 |         if (GazeManager.Instance.Hit)
27 |         {
28 |             RaycastHit hitInfo = GazeManager.Instance.HitInfo;
29 |             if (hitInfo.collider != null)
30 |             {
31 |                 // Assign the hitInfo's collider gameObject to the FocusedGameObject.
32 |                 FocusedGameObject = hitInfo.collider.gameObject;
33 |             }
34 |             else
35 |             {
36 |                 FocusedGameObject = null;
37 |             }
38 |         }
39 |         else
40 |         {
41 |             FocusedGameObject = null;
42 |         }
43 | 
44 |         if (FocusedGameObject != oldFocusedGameObject)
45 |         {
46 |             ResetFocusedInteractible();
47 | 
48 |             if (FocusedGameObject != null)
49 |             {
50 |                 if (FocusedGameObject.GetComponent<Interactible>() != null)
51 |                 {
52 |                     // Send a GazeEntered message to the FocusedGameObject.
53 |                     isSelected = true;
54 |                 }
55 |             }
56 |         }
57 |     }
58 | 
59 |     private void ResetFocusedInteractible()
60 |     {
61 |         if (oldFocusedGameObject != null)
62 |         {
63 |             if (oldFocusedGameObject.GetComponent<Interactible>() != null)
64 |             {
65 |                 // Send a GazeExited message to the oldFocusedGameObject.
66 |                 isSelected = false;
67 |             }
68 |         }
69 |     }
70 | }


--------------------------------------------------------------------------------
/Scripts/PADManager.cs:
--------------------------------------------------------------------------------
 1 | //Here all the movement related to gazing at the DPAD is made.
 2 | 
 3 | using UnityEngine;
 4 | using Scripts;
 5 | 
 6 | public class PADManager : Singleton<PADManager>
 7 | {
 8 |     public Button forwardButton;
 9 | 
10 |     public Button backwardButton;
11 | 
12 |     public Button countercklw;
13 | 
14 |     public Button cklw;
15 | 
16 |     public GameObject turtle;
17 | 
18 |     void Start()
19 |     {
20 | 
21 |     }
22 | 
23 |     void Update()
24 |     {
25 |         if (Source.Instance.con)
26 |         {
27 |             forwardButton.SetActive(true);
28 |             backwardButton.SetActive(true);
29 |             countercklw.SetActive(true);
30 |             cklw.SetActive(true);
31 | 
32 |             PerformMovement();
33 |         }
34 |         else
35 |         {
36 |             forwardButton.SetActive(false);
37 |             backwardButton.SetActive(false);
38 |             countercklw.SetActive(false);
39 |             cklw.SetActive(false);
40 |         }
41 |     }
42 | 
43 |     private void PerformMovement()
44 |     {
45 |         if (InteractibleManager.Instance.FocusedGameObject == GameObject.Find("DPAD/Forward") &&
46 |             forwardButton.IsOn())
47 |         {
48 |             turtle.transform.localPosition += Vector3.right * 0.005f;
49 |         }
50 |         else if (InteractibleManager.Instance.FocusedGameObject == GameObject.Find("DPAD/Backward") &&
51 |             backwardButton.IsOn())
52 |         {
53 |              turtle.transform.localPosition += -Vector3.right * 0.005f;
54 |         }
55 | 
56 |         if (InteractibleManager.Instance.FocusedGameObject == GameObject.Find("DPAD/CounterClockwise") &&
57 |             countercklw.IsOn())
58 |         {
59 |             turtle.transform.localPosition += Vector3.up * 0.005f;
60 |         }
61 |         else if (InteractibleManager.Instance.FocusedGameObject == GameObject.Find("DPAD/Clockwise") &&
62 |             cklw.IsOn())
63 |         {
64 |             turtle.transform.localPosition += -Vector3.up * 0.005f;
65 |         }
66 |     }
67 | }
68 | 


--------------------------------------------------------------------------------
/Scripts/ResetManager.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | 
 4 | public class ResetManager : MonoBehaviour
 5 | {
 6 | 
 7 |     public Button resetButton;
 8 | 
 9 |     // Use this for initialization
10 |     void Start()
11 |     {
12 | 
13 |     }
14 | 
15 |     // Update is called once per frame
16 |     void Update()
17 |     {
18 | 
19 |         if (InteractibleManager.Instance.FocusedGameObject == gameObject && Source.Instance.con)
20 |         {
21 |             resetButton.SetActive(true);
22 |         }
23 |         else
24 |         {
25 |             resetButton.SetActive(false);
26 |         }
27 | 
28 |     }
29 | 
30 |     void OnSelect()
31 |     {
32 |         if (resetButton.IsOn())
33 |         {
34 |             //Resetting turtle/cube to initial position.
35 |             Source.Instance.turtle.transform.localPosition = new Vector3(0, 0, -0.7f);
36 |         }
37 | 
38 |     }
39 | }
40 | 
41 | 


--------------------------------------------------------------------------------
/Scripts/Singleton.cs:
--------------------------------------------------------------------------------
 1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
 2 | 
 3 | using UnityEngine;
 4 | 
 5 | namespace Scripts
 6 | {
 7 |     public class Singleton<T> : MonoBehaviour where T : Singleton<T>
 8 |     {
 9 |         private static T _Instance;
10 |         public static T Instance
11 |         {
12 |             get
13 |             {
14 |                 if (_Instance == null)
15 |                 {
16 |                     _Instance = FindObjectOfType<T>();
17 |                 }
18 |                 return _Instance;
19 |             }
20 |         }
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/Scripts/Source.cs:
--------------------------------------------------------------------------------
  1 | //Here the connection and interaction between Unity/HL and ROS is made.
  2 | 
  3 | //Two different WebSockets libraries are used to establish a connection.
  4 | //WebSocketSharp provides a websocket client that allow us to connect Unity with ROS via RosBridge. 
  5 | //Since this library it is not available for Windows Store Apps (HL format), Windows.Networking.Socket is responsible
  6 | //for connecting HL and ROS.
  7 | 
  8 | //Pieces of code wrapped in #if UNITY_EDITOR are used only when Unity Play mode is running.
  9 | //Pieces of code wrapped in #if !UNITY_EDITOR are used only when the app is running on HL.
 10 | 
 11 | //Methodology for establishing an async Rosbridge connection during Unity play mode and to build a message responsible for accessing and 
 12 | //sending a ROS service message were given here: 
 13 | //github.com/2016UAVClass/Simulation-Unity3D @author Michael Jenkin, Robert Codd-Downey and Andrew Speers
 14 | 
 15 | using UnityEngine;
 16 | using Scripts;
 17 | using System;
 18 | using System.Collections.Generic;
 19 | using System.Reflection;
 20 | 
 21 | #if UNITY_EDITOR
 22 | using WebSocketSharp;
 23 | using System.Threading;
 24 | #endif
 25 | 
 26 | #if !UNITY_EDITOR
 27 | using Windows.Networking.Sockets;
 28 | using Windows.Storage.Streams;
 29 | using Windows.Networking;
 30 | using Windows.Foundation;
 31 | using Windows.UI.Core;
 32 | #endif
 33 | 
 34 | public class Source : Singleton<Source> {
 35 | 
 36 |     public Button communicator;
 37 | 
 38 |     //VM IP adress used for connection
 39 |     private string host = "173.250.182.160";
 40 | 
 41 |     //Default ROSBridge port
 42 |     private int port = 9090;
 43 |     public bool con = false;
 44 | 
 45 |     public GameObject turtle;
 46 |     public GameObject plane;
 47 | 
 48 |     //Value that will be send to teleport_absolute
 49 |     public float tx, ty;
 50 | 
 51 | #if UNITY_EDITOR
 52 |     //WebSocket client from WebSocketSharp
 53 |     private WebSocket Socket;
 54 |     private Thread Thread;
 55 | #endif
 56 | 
 57 |     //WebSocket client from Windows.Networking.Sockets
 58 | #if !UNITY_EDITOR
 59 |     private MessageWebSocket messageWebSocket;
 60 |     Uri server;
 61 |     DataWriter dataWriter;
 62 | #endif
 63 | 
 64 |     void Update()
 65 |     {
 66 | 
 67 | #if UNITY_EDITOR
 68 |         //Connecting in Unity play mode
 69 |         if (Input.GetKeyDown(KeyCode.C))
 70 |         {
 71 |             Connect();
 72 |         }
 73 | 
 74 |         //Disconnecting in Unity play mode
 75 |         if (Input.GetKeyDown(KeyCode.E))
 76 |         {
 77 |             Disconnect();
 78 |         }
 79 | 
 80 |         //Reset in Unity Play mode
 81 |         if (Input.GetKeyDown(KeyCode.I))
 82 |         {
 83 |             turtle.transform.localPosition = new Vector3(0, 0, -0.7f);
 84 |         }
 85 | 
 86 |         //Clear in Unity Play mode
 87 |         if (Input.GetKeyDown(KeyCode.R))
 88 |         {
 89 |             SendService("/clear", "");
 90 |         }
 91 | 
 92 | #endif
 93 |         if (con)
 94 |         {
 95 |             communicator.ChangeButtonState(Button.State.Selected);
 96 | 
 97 |             turtle.SetActive(true);
 98 | 
 99 |             plane.GetComponent<Renderer>().material.color = new Color(0, 0, 0.4f);
100 | 
101 |             turtle.transform.parent = plane.transform;
102 | 
103 | #if UNITY_EDITOR
104 |             //Moving in Unity play mode
105 |             if (Input.GetKey(KeyCode.W))
106 |             {
107 |                 turtle.transform.localPosition += Vector3.up * 0.005f;
108 |             }
109 | 
110 |             if (Input.GetKey(KeyCode.S))
111 |             {
112 |                 turtle.transform.localPosition += -Vector3.up * 0.005f;
113 |             }
114 | 
115 |             if (Input.GetKey(KeyCode.D))
116 |             {
117 |                 turtle.transform.localPosition += Vector3.right * 0.005f;
118 |             }
119 | 
120 |             if (Input.GetKey(KeyCode.A))
121 |             {
122 |                 turtle.transform.localPosition += -Vector3.right * 0.005f;
123 |             }
124 | #endif
125 |             
126 |             //Taking the cube position from the simulated environment and scaling to a compatible value that will be
127 |             //send to ROS to update the turtle position.
128 |             tx = (5.54f + (turtle.transform.localPosition.x * 11.78f));
129 |             ty = (5.54f + (turtle.transform.localPosition.y * 11.78f));
130 | 
131 |             //Accessing ROS service turtle1/teleport_absolute to update turtle position
132 |             SendService("/turtle1/teleport_absolute", "{\"x\": " + tx + ", \"y\": " + ty + ", \"theta\": 0}");
133 |         }
134 |         else
135 |         {
136 |             communicator.ChangeButtonState(Button.State.Inactive);
137 | 
138 |             plane.GetComponent<Renderer>().material.color = new Color(1, 1, 1);
139 | 
140 |             turtle.SetActive(false);
141 |         }
142 | 
143 |     }
144 | 
145 | //Tap Gesture on HL
146 | #if !UNITY_EDITOR
147 |     void OnSelect()
148 |     {
149 |         if ((InteractibleManager.Instance.FocusedGameObject == GameObject.Find("Connector")) && (!con))
150 |         {
151 |             Connect();
152 |         }
153 | 
154 |         if ((InteractibleManager.Instance.FocusedGameObject == GameObject.Find("Connector")) && (con))
155 |         {
156 |             Disconnect();
157 |         }
158 |     }
159 | #endif
160 | 
161 |     public void Connect()
162 |     {
163 |         //Async connection.
164 | #if UNITY_EDITOR
165 |         Thread = new Thread(Run);
166 |         Thread.Start();
167 | #endif
168 | 
169 | #if !UNITY_EDITOR
170 |         
171 |         messageWebSocket = new MessageWebSocket();
172 | 
173 |         server = new Uri("ws://" + host + ":" + port.ToString());
174 | 
175 |         IAsyncAction outstandingAction = messageWebSocket.ConnectAsync(server);
176 |         AsyncActionCompletedHandler aach = new AsyncActionCompletedHandler(NetworkConnectedHandler);
177 |         outstandingAction.Completed = aach;
178 | #endif
179 |     }
180 | 
181 | //Successfull network connection handler on HL
182 | #if !UNITY_EDITOR
183 |     public void NetworkConnectedHandler(IAsyncAction asyncInfo, AsyncStatus status)
184 |     {
185 |         // Status completed is successful.
186 |         if (status == AsyncStatus.Completed)
187 |         {
188 |             //Guarenteed connection
189 |             con = true;
190 |             
191 |             //Creating the writer that will be repsonsible to send a message through Rosbridge
192 |             dataWriter = new DataWriter(messageWebSocket.OutputStream);
193 | 
194 |         }
195 |         else
196 |         {
197 |             con = false;
198 |         }
199 |     }
200 | #endif
201 | 
202 | //Starting connection between Unity play mode and ROS.
203 |     private void Run()
204 |     {
205 | #if UNITY_EDITOR
206 |         Socket = new WebSocket("ws://" + host + ":" + port);
207 |         Socket.Connect();
208 |         con = true;
209 | 
210 |         while (true)
211 |         {
212 |             Thread.Sleep(10000);
213 |         }
214 | #endif
215 |     }
216 | 
217 |     public void Disconnect()
218 |     {
219 | //Killing connection
220 | #if UNITY_EDITOR
221 |         Thread.Abort();
222 |         Socket.Close();
223 |         con = false;
224 | #endif
225 | 
226 | #if !UNITY_EDITOR
227 |         messageWebSocket.Dispose();
228 |         messageWebSocket = null;
229 |         con = false;
230 | #endif
231 |     }
232 | 
233 | #if UNITY_EDITOR
234 |     void OnApplicationQuit()
235 |     {
236 |         Thread.Abort();
237 |         Socket.Close();
238 |         con = false;
239 |     }
240 | #endif
241 | 
242 | //Sending the service message
243 |     public void SendService(string service, string args)
244 |     {
245 | #if UNITY_EDITOR
246 |         if (Socket != null)
247 |         {
248 |             string s = CallService(service, args);
249 |             Socket.Send(s);
250 |         }
251 | #endif
252 | 
253 | #if !UNITY_EDITOR
254 |         if (messageWebSocket != null)
255 |         {
256 |             string s = CallService(service, args);
257 |             dataWriter.WriteString(s);
258 |             dataWriter.StoreAsync();
259 |         }
260 | #endif
261 |     }
262 | 
263 | //Building the service message that will be send to ROS
264 |     public static string CallService(string service, string args)
265 |     {
266 |         if ((args == null) || args.Equals(""))
267 |             return "{\"op\": \"call_service\", \"service\": \"" + service + "\"}";
268 |         else
269 |             return "{\"op\": \"call_service\", \"service\": \"" + service + "\", \"args\" : " + args + "}";
270 |     }
271 | 
272 | }


--------------------------------------------------------------------------------
/Scripts/SpatialMapping.cs:
--------------------------------------------------------------------------------
  1 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
  2 | //Environment recognition and mesh drawing.
  3 | 
  4 | using System.Collections.Generic;
  5 | using UnityEngine;
  6 | using UnityEngine.VR.WSA;
  7 | 
  8 | public class SpatialMapping : MonoBehaviour
  9 | {
 10 |     public static SpatialMapping Instance { private set; get; }
 11 |     public static int PhysicsRaycastMask;
 12 | 
 13 |     [Tooltip("The material to use when rendering Spatial Mapping data.")]
 14 |     public Material DrawMaterial;
 15 |     [Tooltip("If true, the Spatial Mapping data will be rendered.")]
 16 |     public bool DrawVisualMeshes = false;
 17 | 
 18 |     // The frequency (in seconds) which to call Update() on our SMSurfaceObserver
 19 |     private float UpdateFrequency = 2.5f;
 20 |     // The physics layer where Spatial Mapping data will live.
 21 |     private int PhysicsLayer = 31;
 22 |     // The number of Triangles per m^3 for the SMSurfaceObserver to calculate.
 23 |     private float TrianglesPerCubicMeter = 500f;
 24 |     // The volume of space the SMSurfaceObserver should observe.
 25 |     private Vector3 BoundingVolume = Vector3.one * 10.0f;
 26 |     // Our Spatial Mapping Surface Observer object
 27 |     private SurfaceObserver Observer;
 28 |     // A dictionary of surfaces (Meshes) that our Surface Observer knows about.
 29 |     private Dictionary<int, GameObject> surfaces;
 30 |     // Queue of SurfaceData information. Enqueued in OnSurfaceChanged; Dequeued in Update.
 31 |     private Queue<SurfaceData> surfaceDataQueue;
 32 |     // If true, Spatial Mapping is enabled. 
 33 |     private bool mappingEnabled = true;
 34 | 
 35 |     /// <summary>
 36 |     /// To prevent too many meshes from being generated at the same time, we will
 37 |     /// only request one mesh to be created at a time.  This variable will track
 38 |     /// if a mesh creation request is in flight.
 39 |     /// </summary>
 40 |     private bool surfaceWorkOutstanding = false;
 41 | 
 42 |     void Awake()
 43 |     {
 44 |         Instance = this;
 45 |         // Convert the layer into a mask so it can be used to Raycast against.
 46 |         PhysicsRaycastMask = 1 << PhysicsLayer;
 47 |     }
 48 | 
 49 |     // Use this for initialization
 50 |     void Start()
 51 |     {
 52 |         Observer = new SurfaceObserver();
 53 |         Observer.SetVolumeAsAxisAlignedBox(Vector3.zero, BoundingVolume);
 54 |         surfaces = new Dictionary<int, GameObject>();
 55 |         surfaceDataQueue = new Queue<SurfaceData>();
 56 |         UpdateSurfaceObserver();
 57 |     }
 58 | 
 59 |     private void UpdateSurfaceObserver()
 60 |     {
 61 |         if (mappingEnabled)
 62 |         {
 63 |             Observer.Update(Observer_OnSurfaceChanged);
 64 |             Invoke("UpdateSurfaceObserver", UpdateFrequency);
 65 |         }
 66 |     }
 67 | 
 68 |     private void Observer_OnSurfaceChanged(SurfaceId surfaceId, SurfaceChange changeType, Bounds bounds, System.DateTime updateTime)
 69 |     {
 70 |         GameObject surface;
 71 | 
 72 |         switch (changeType)
 73 |         {
 74 |             case SurfaceChange.Updated:
 75 |             case SurfaceChange.Added:
 76 |                 if (!surfaces.TryGetValue(surfaceId.handle, out surface))
 77 |                 {
 78 |                     // If we are adding a new surface, construct a GameObject
 79 |                     // to represent its state and attach some Mesh-related
 80 |                     // components to it.
 81 |                     surface = new GameObject(string.Format("Surface-{0}", surfaceId));
 82 |                     surface.AddComponent<MeshFilter>();
 83 |                     surface.AddComponent<MeshRenderer>().sharedMaterial = DrawMaterial;
 84 |                     surface.AddComponent<MeshCollider>();
 85 |                     surface.AddComponent<WorldAnchor>();
 86 |                     // Set the layer that this SpatialMapping surface is a part of
 87 |                     surface.layer = PhysicsLayer;
 88 |                     // Add the surface to our dictionary of known surfaces so
 89 |                     // we can interact with it later.
 90 |                     surfaces[surfaceId.handle] = surface;
 91 |                 }
 92 | 
 93 |                 SurfaceData smsd = new SurfaceData(
 94 |                     surfaceId,
 95 |                     surface.GetComponent<MeshFilter>(),
 96 |                     surface.GetComponent<WorldAnchor>(),
 97 |                     surface.GetComponent<MeshCollider>(),
 98 |                     TrianglesPerCubicMeter,
 99 |                     true);
100 |                 surfaceDataQueue.Enqueue(smsd);
101 |                 break;
102 | 
103 |             case SurfaceChange.Removed:
104 |                 if (surfaces.TryGetValue(surfaceId.handle, out surface))
105 |                 {
106 |                     surfaces.Remove(surfaceId.handle);
107 |                     Destroy(surface);
108 |                 }
109 |                 break;
110 |         }
111 |     }
112 | 
113 |     void Update()
114 |     {
115 |         if (mappingEnabled)
116 |         {
117 |             foreach (GameObject surface in surfaces.Values)
118 |             {
119 |                 surface.GetComponent<MeshRenderer>().enabled = DrawVisualMeshes;
120 |             }
121 | 
122 |             if (surfaceWorkOutstanding == false && surfaceDataQueue.Count > 0)
123 |             {
124 |                 SurfaceData smsd = surfaceDataQueue.Dequeue();
125 |                 surfaceWorkOutstanding = Observer.RequestMeshAsync(smsd, Observer_OnDataReady);
126 |             }
127 |         }
128 |     }
129 | 
130 |     /// <summary>
131 |     /// Handles the SurfaceObserver's OnDataReady event.
132 |     /// </summary>
133 |     /// <param name="cookedData">Struct containing output data.</param>
134 |     /// <param name="outputWritten">Set to true if output has been written.</param>
135 |     /// <param name="elapsedCookTimeSeconds">Seconds between mesh cook request and propagation of this event.</param>
136 |     private void Observer_OnDataReady(SurfaceData bakedData, bool outputWritten, float elapsedBakeTimeSeconds)
137 |     {
138 |         surfaceWorkOutstanding = false;
139 |     }
140 | 
141 |     public void SetMappingEnabled(bool isEnabled)
142 |     {
143 |         mappingEnabled = isEnabled;
144 |         foreach (GameObject surface in surfaces.Values)
145 |         {
146 |             surface.SetActive(isEnabled);
147 |         }
148 |         UpdateSurfaceObserver();
149 |     }
150 | }


--------------------------------------------------------------------------------
/Scripts/TapToPlace.cs:
--------------------------------------------------------------------------------
 1 | //Responsible for the placement of the Enviroment on the Visual Meshes around you
 2 | //Based on the class originated from github.com/Microsoft/HoloToolkit-Unity/
 3 | using UnityEngine;
 4 | 
 5 | public class TapToPlace : MonoBehaviour
 6 | {
 7 |     bool placing = false;
 8 | 
 9 |     // Called by GazeGestureManager when the user performs a Select gesture
10 |     void OnSelect()
11 |     {
12 |         if (InteractibleManager.Instance.FocusedGameObject == GameObject.Find("Environment/Plane"))
13 |         {
14 |             // On each Select gesture, toggle whether the user is in placing mode.
15 |             placing = !placing;
16 | 
17 |             // If the user is in placing mode, display the spatial mapping mesh.
18 |             if (placing)
19 |             {
20 |                 SpatialMapping.Instance.DrawVisualMeshes = true;
21 |             }
22 |             // If the user is not in placing mode, hide the spatial mapping mesh.
23 |             else
24 |             {
25 |                 SpatialMapping.Instance.DrawVisualMeshes = false;
26 |             }
27 |         }
28 |     }
29 | 
30 |     // Update is called once per frame
31 |     void Update()
32 |     {
33 | 
34 |         if (!Source.Instance.con)
35 |         {
36 |             if (placing)
37 |             {
38 |                 // Do a raycast into the world that will only hit the Spatial Mapping mesh.
39 |                 var headPosition = Camera.main.transform.position;
40 |                 var gazeDirection = Camera.main.transform.forward;
41 | 
42 |                 RaycastHit hitInfo;
43 |                 if (Physics.Raycast(headPosition, gazeDirection, out hitInfo,
44 |                     30.0f, SpatialMapping.PhysicsRaycastMask))
45 |                 {
46 |                     // Move this object's parent object to
47 |                     // where the raycast hit the Spatial Mapping mesh.
48 |                     transform.position = hitInfo.point;
49 |                 }
50 |             }
51 |         }
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/Scripts/TextManager.cs:
--------------------------------------------------------------------------------
 1 | //Connector text box gameObject
 2 | 
 3 | using UnityEngine;
 4 | using Scripts;
 5 | 
 6 | public class TextManager : Singleton<TextManager>
 7 | {
 8 |     public GameObject connectorInfo;
 9 | 
10 |     void Awake()
11 |     {
12 | 
13 |     }
14 | 
15 |     void Update()
16 |     {
17 |         connectorInfo.SetActive(true);
18 |     }
19 | }


--------------------------------------------------------------------------------
/Scripts/tipText.cs:
--------------------------------------------------------------------------------
 1 | //Manage the connector text box status
 2 | 
 3 | using UnityEngine;
 4 | using UnityEngine.UI;
 5 | 
 6 | public class tipText : MonoBehaviour
 7 | {
 8 |     public Text tipMessage;
 9 | 
10 |     void Update()
11 |     {
12 |         if(Source.Instance.con)
13 |         {
14 |             tipMessage.text = "Connected. Select to disconnect.";
15 |         }
16 |         else
17 |         {
18 |             tipMessage.text = "Select to connect.";
19 |         }
20 |     }
21 | }


--------------------------------------------------------------------------------
/holoROS.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/soliagabriel/holoROS/80df39071b5eb75f430b3ea37c725153e581473b/holoROS.zip


--------------------------------------------------------------------------------