Introduction

On Monday, we talked about how to add the Humanoid ThirdPersonController named Ethan to a scene. We also showed how to add his scriptable variant AIThirdPersonController.
We showed how to estimate how tall Ethan was by placing a unit cube next to him. This showed he was about 1.6-1.7 units tall (if a unit is a meter this is about average height).
To move in a scene an AIThirdPersonController makes use of the values from its Nav Mesh Agent and AI Character Control Script component in the Inspector tab.
We said a NavMesh is a graph based on the scene of obstacles that need to be avoided in moving from point A to B.
We said how to open a Navigation tab from the main menu via Window - AI - Navigation. Then if we select each object in our Hierarchy pane and look in the Navigation tab we can check Navigation Static. After doing this for each non-moving, solid objects, we click on the Bake sub-tab and click Bake to build a NavMesh.
Once built, we showed we could add an empty game object to our scene, set its position how we want, and by dragging this object into Ethan's Inspector, AI Character Control Script's Target value, get it so that Ethan walks to the GameObject's position.
We then showed how to add a script to the game object via Add Component in its inspector panel.
We then showed how to script where the game object was in the scene by either repositioning it randomly, or by having it track where we were looking in the scene.
We demonstrated how public fields of the MonoBehavior class (recall Mono is an open source variant of C#) used for scripting show up in the Inspector for script components of objects and that we can drag components of our Hierarchy to these to say use them as the value of that field.
We showed how to add a cylinder to this game object as a sub-object so that we could fake something like a where looking object in the latter case.
We then showed how to make Ethan explode if we looked at him too long.
Where we were looking on the ground or when we looking at Ethan was determined in our scripts using raycasting.
Today, we start by looking at yet another way to measure things in a scene, before talking about adding controllers, etc.

Grid Projectors

As we mentioned last day, in order to make a VR scene comfortable, it is useful to keep things at a familiar real world scale.
To measure the relative heights of things, we said that we can take a unit cube and drag it into our scene next to an object that we'd like to determine the scale of.
Another approach is to use a Grid Projector. This Asset can be found by looking under Assets - Standard Assets - Effects - Projectors - Prefabs. We can drag it into our Hierarchy Pane much like any other Game Object.
Recall, on Monday, we said how to import Standard Assets if it wasn't already imported.
The idea of a Grid Projector is that it projects a grid as a light on to a scene from a particular perspective.
You can think of this as if we had our classroom slide projector display a grid pattern against a wall or in a given direction.
We can use the grid projector to help lay things out on the ground. By default the Rotation and Position this projection is from can be controlled by the Transform component of its Inspector pane. We can set the Rotation to (90, 0, 0) if its not that already, and its position to (-2.5, 5, -0.5).
By default, the projector display light gray lines which can be hard to see. To fix this, click on the projector in the Hierarchy Pane, and change its Shader from Projector/Light to Projector/Multiply.
In the Center pane use the Scene view gizmo to view the scene from top using an Orthographic projection.
Also, under the Grid Projector's Inspector - Projector component check the Orthographic check box.
If we dragged a unit cube out onto the scene in the above set up, the cube would be about two grid markings wide. To make it one grid marking wide, we can change the Orthographic Size to 0.5.
The GridProjector's Inspector pane should look like:

and the center pane scene might look like:
Notice the unit cube exactly fills one square.
We can toggle the grid projector on and off by clicking the checkbox next to its name in its Inspector pane.

Making a Prefab Balloon

Let's make a scene where every time we click the Oculus Go controller trigger a balloon is created and floats up.
Add a new empty Game Object to your Hierarchy pane, add a Sphere as a sub object of this and change its default Material so that the sphere is blue.
Using the gear box on your Game Object's Inspector Transform component select Reset to reset its transform. Set the Sphere sub object's position now to (0, 0.5, 0).
Change the Balloon's scale to (0.1, 0.1, 0.1) and its position to (0,1,1).
To specify the Balloon's physics we click on its Add Component in Inspector and select Physics - RigidBody. We then uncheck Use Gravity.
The Inspector pane for balloon should look like:
We want to be able to generate many balloons, all from a template. To do this, in our Project Pane, click on Assets and make a new Prefabs folder if it doesn't exist. Drag our Balloon object to this folder.
Notice, if you click in the Project Pane, then on All Prefabs, you should be able to see a Balloon Prefab.
We can now delete the Balloon from our Hierarchy Pane. If we ever want to change our prefab, we click on it in Prefabs and then click Open Prefab, make changes, and save.

In-Class Exercise

Make a Red Balloon Prefab. Take a screen shot of it in the All Assets folder.
Post your solutions to the Apr 24 In-Class Exercise Thread.

Responding to Clicks

Click on the OVRCameraRig in our Hierarchy pane. Then click Add Component to add a New Script and name it MyInputController.

Under the Project Pane - Assets, select the script, and move it into your Scripts folder, double click on it to edit it, and add:

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

public class MyInputController : MonoBehaviour
{

    // Update is called once per frame
    void Update()
    {
        ButtonTest();   
    }
    private void ButtonTest()
    {
        string msg = null;
        if (Input.GetButtonDown("Fire1")) {
            msg = "Fire1 down";
        }
        if (Input.GetButtonUp("Fire1")) {
            msg = "Fire1 up";
        }
        if (msg != null) {
            Debug.Log("Input: " + msg);
        }
    }
}

If you click the Play button above the Center Pane in Unity, you'll notice if you click on the track pad or mouse. It will print to the console now:
If we install the app on an Oculus Go by choosing Build and Run, then pull the Trigger on the controller it will write to the devices log.

We can see the messages by typing at a command prompt:
adb logcat -s Unity

04-24 11:43:49.890  8249  8264 I Unity   : 
04-24 11:44:15.932  8249  8264 I Unity   : Input: Fire1 down
04-24 11:44:15.932  8249  8264 I Unity   :  
04-24 11:44:15.932  8249  8264 I Unity   : (Filename: ./Runtime/Export/Debug/Debug.bindings.h Line: 48)
04-24 11:44:15.932  8249  8264 I Unity   : 
04-24 11:44:16.083  8249  8264 I Unity   : Input: Fire1 up
04-24 11:44:16.083  8249  8264 I Unity   :  
04-24 11:44:16.083  8249  8264 I Unity   : (Filename: ./Runtime/Export/Debug/Debug.bindings.h Line: 48)
04-24 11:44:16.083  8249  8264 I Unity   :

Adding a Remote to the Scene

When something is a prefab, we can't edit in Hierarchy Pane, for instance, by clicking on it.
We can modify this for a prefac in our Hierarchy pane, by right clicking on it, and choosing Unpack Prefab. Do this for OVRCameraRig.
If we open up the camera rig tree in Hierarchy Pane OVRCameraRig - TrackingSpace - RightHandAnchor - RightControllerAnchor, we can then drag the Oculus - VR - Prefabs - Tracked Remote prefab to the Hierarchy pane:
If we save our Scene and do Build and Run, we should see the Oculus Go controller in the Scene, and it should follow our hand movements.
To add a laser pointer, we can unpack the Tracked Remote prefab, right click on it in our Hierarchy Pane, and add Effects - Line.
We can then tweak this line so it looks like a laser pointer.

Oculus Inputs

Oculus Integration provides more robust controller support through the OVRInput class rather than Input that we just used.
It is described on the Oculus OVRInput page.
In particular, OVRInput.GetLocalControllerPosition(SomeController) and OVRInput.GetLocalControllerRotation(SomeController) tell us the controller position and rotation.

We can find out if a controller is connected via:

OVRInput.IsControllerConnected(OVRInput.Controller.RTrackedRemote);

One can use the methods OVRInput.Get, OVRInput.GetUp, OVRInput.GetDown to get the state of various UI components. For example,

//true if trigger pressed
OVRInput.Get(OVRInput.Button.One);
// returns a Vector2 of the primary touchpad position
OVRInput.Get(OVRInput.Axes2D.PrimaryTouchPad);

Here is a picture showing how things are named:

Connecting Actions to Controller Input

Using either Input or OVRInput, we can now have our script call a method when the trigger is down (NewBalloon() )or up (ReleaseBalloon() ). So our Update() method now becomes:

    private void ButtonTest()
    {
        string msg = null;
        if (Input.GetButtonDown("Fire1")) {
        //OVRInput.GetDown(OVRInput.Button.One) also works
            msg = "Fire1 down";
            NewBalloon();
        }
        if (Input.GetButtonUp("Fire1")) {
        //OVRInput.GetUp(OVRInput.Button.One) also works
            msg = "Fire1 up";
            ReleaseButton();
        }
        if (msg != null) {
            Debug.Log("Input: " + msg);
        }
    }

Let's add a public field for our Balloon prefab to our script:

public GameObject balloonPrefab; //remember to drag the prefab over to this in My Input Controller
public float floatStrength = 20f;

and another private variable to hold the current instance of the balloon:

private GameObject balloon;

Below is the code for NewBalloon and ReleaseBalloon():

private void NewBalloon()
{
    balloon = Instantiate(balloonPrefab);
}
private void ReleaseButton()
{
    // observe how we refer to a sub component.
    balloon.GetComponent<Rigidbody>().AddForce(Vector3.up * floatStrength);
    balloon = null; /* Setting Balloon only gets rid of our reference,
       not the object. To actually remove an object use:
       Destroy (someGameObject); */ 
}

Skyboxes

A skybox is an image or video that is painted on the sky in a Unity Scene.
To make a skybox we make a new material.
As its Shader we choose Skybox - Panoramic.
We import the image or video source we are using for our Skybox into our Asset - Textures folder by dragging it there.
If our skybox is just an image, then we drag from our Asset - Textures its Texture to the Texture field of the Skybox and our Material is ready for use.
If our skybox is going to use a video the setup is a little more complicated. We can follow these steps:
1. Create a new Empty game object in our Hierarchy Pane, rename it VideoPlayer.
2. Click on its Add Component in Inspector, and add a Video - Video Player.
3. Drag the Texture you got from your video when you imported it into your Textures Folder to the VideoPlayer's Video Clip field in Inspector.
4. Make sure the Loop checkbox is checked.
5. Now create in Assets - Textures a Render Texture and rename it Video Renderer. Adjust the Size of Video Renderer to match the dimensions of your video, set Anti-Aliasing to 2 samples, set the Depth Buffer to No Depth Buffer.
6. Look at the VideoPlayer's Inspector and drag to its Target field the Video Renderer texture (this says the player will play to this texture).
7. Now drag this Texture to the Texture field of our Skybox to make the Skybox material ready to use.
If our texture is a 3D 360, in our Skybox material, under 3D Layout, we specify Over Under for our video.
To use our Skybox material in the Scene open the Light Tab under Window - Rendering- Lighting Settings.
Drag the Skybox Material onto the Skybox Material Slot.

Audio Clips and Sources

An AudioClip is a container for some sound that you import into Unity.
Find some sound you'd like to play when the trigger is pressed.
Under Assets make a new folder Sounds. Drag your sound file into this folder, say missile.mp3, this will create an AudioClip object to be added to this folder. Let's rename it Missile.
Next we add an AudioSource to our Hierarchy, and drag the AudioClip from Assets - Sounds over to fill in its clip field.
To add an Audio Clip to an Object or Scene we can go to Add Component - Audio - Audio Source.
It has an Audio Source field that you can drag sound clips into.
Uncheck the AudioSources' Play On Awake checkbox.
To our earlier MyInputController, we next add a public field:
```
    public AudioSource missile;
```
and make sure in OVRCameraRig's Inspector - My Input Controller script we drag our Audio Source over to fill in the value for the Missle field.

Now in our code we can play the clip using the Play() method:

        if (Input.GetButtonDown("Fire1")) {
            msg = "Fire1 down";
            NewBalloon();
            missile.Play();
        }

In this particular case, we added the AudioSource to the whole Scene. We can also click on Add Component to add an AudioSource to that particular component. If you look under 3D Sound Settings of an AudioSource, you can see/set how the quickly the sound will die off with distance from the object on which the AudioSource lives.
If we wanted to play an AudioSource on a GameObject, we could have used:
```
    public GameObject myObject;
```
then referred to its AudioSource with myObject.GetComponent<AudioSource>()

Unity Controllers, Skyboxes, Audio

Outline