Oculus SDK (OVR)

@Brandon

Requirements

• Installation of Unity

Comments

The Oculus SDK "Throw a Ball" tutorial is meant to serve as a point of comparison with the previous SteamVR plugin Throw a Ball tutorial, and will reproduce the same result. Therefore, many sections of the following tutorial, especially the beginning will be the exact same as sections in the SteamVR Throw a Ball tutorial. However, this tutorial is in no way an end all be all in determining which SDK is more preferable for VR developers, but rather to provide another option in pursuing VR development in Unity.

With everything white, it'll be pretty hard to see everything, so let's add some color to our project.

Create a new folder in "Assets" and name it "Materials" (refer to the "Save Scene" section for a refresher). Navigate to that folder and create a new Material (Create>Material). Let's name it "Ball," since we will use this to make our ball look extra sleek and schwifty. In the material's inspector, we can change all sorts of attributes relating to how something looks. There should be a dropper in the upper area of the inspector. Clicking that will allow us to pick a color. I picked red, but I encourage you to go as wild as you can when it comes to picking ball colors. In the inspector, there are also sliders that can make make the material look more shiny/metallic, or look smoother.

Once you are satisfied with how the material looks, drag the material from the Materials folder to the the desired object in the hierarchy menu (in this case, it would be ball). The object should now have the texture and color in the scene view. 

Let's make some materials for the rest of the objects in the scene to give the project some extra personality!

There should be an arrow on the left that shows child elements of OVRPlayerController. Click it, and it should OVRCameraRig, which should contain Tracking Space, which in turn, contains the Left and Right hand anchors, which is what we'll specifically be working with in this tutorial. Ctrl/Cmd + Click both the Left and Right hand anchors. This allows us to change both at the same time.

Since we want our hands to also be able to interact with physical objects, we'll need some sort of physical body for the hands. With both anchors selected in the hierarchy menu, right click and create a new sphere. This should create a sphere as a child for both the left and right hands. 

Now select both spheres. Something you might have noticed at this point, and would be extremely obvious if we were to run the program right now on the Oculus headset is that these spheres are huge! We want them to roughly be the size of a hand, so in the transform section, change the x, y, and z for scale to 0.1, which should make them the size of tennis balls. We want these "hands" to actually detect and grab objects, not just push them around, so under box collider, check "Is Trigger." This will make it so that the sphere passes through objects, and sends a signal when it does. Lastly, it will be useful to be able to identify the spheres in the future, so in the top name bar in the inspector, name the left and right hand anchor spheres "LeftGrabber" and "RightGrabber" respectively.

Since we don't want our hands to fall down, be sure to uncheck "Use Gravity" and check "Is Kinematic" for both anchors under the rigidbody section.

Navigate to the Assets folder, and make a new folder called "Scripts". 

Just like for the SteamVR tutorial, let's again add the "return ball" script that will make the program a lot easier during runtime. Create a new script and call it BallController.

public class BallController : MonoBehaviour {

    private Vector3 position;

  // Use this for initialization

 void Start () {

        position = transform.position;

 }

 // Update is called once per frame

 void Update () {

  if (transform.position.y < 0)

        {

            var rb = GetComponent<Rigidbody>();

            transform.position = position;

            rb.velocity = Vector3.zero;

            rb.angularVelocity = Vector3.zero;

        }

 }

}

Since our floor is floating in the middle of nowhere, if we throw a ball and it falls off the edge, then we'll have nothing to throw anymore. This script here basically just checks to see if the ball is below the floor. If it is, then return it to its original position. Drag "BallController" to the Ball's inspector.

Having only one ball and once target to knock over seems kind of boring, doesn't it? Let's add some more of each!

Create a new folder in the assets folder called "Prefabs". Now drag "Target" and "Ball" from the hierarchy into the Prefabs folder. Delete them from the Hierarchy Menu.

Prefabs are basically blueprints for objects we make. If we make a Prefab, then we can make multiple copies of that object easily, and if we change one Prefab object, we have the option to change all others made from the same prefab in the same way.

Create two new Game Objects in the Hierarchy Menu (Create>Create Empty) (Be sure that their Transform properties are zero'ed out). Name one "Balls", and the other "Targets". Now drag the ball prefab to "Balls" and the "Target" prefab to Targets (This make the hierarchy menu a little more organized). Now right click the Ball (or Target), and select "duplicate". Now if we select the duplicate in the hierarchy menu and focus on it with "f", we should notice a colored cube with arrows. If we click the bottom face with the cube, you'll notice that we can drag the object around easily without having to manipulate any numbers. This way, we can duplicate a bunch more targets and balls to throw at them.

Bonus section (not necessary, but really cool!):

Although the SteamVR plugin automatically adds the controllers to the view by default, Oculus doesn't do that, if if you were to run the program on an Oculus before adding in the Left and Right grabber spheres, your hands would be invisible, and you would have trouble seeing where the controllers are.

Still, you would get some neat features like being able to move around and turn with the controller joysticks, and the Guardian System, which is the mesh boundary defining the Oculus play area, will still work.

But something really cool about the Oculus SDK is that there is a way to actually have "hands" where your controllers are!

Navigate to the Avatar Prefabs folder (Oculus>Avatar>Content>Prefabs) and drag Local Avatar into the OVRCameraRig tracking space on the hierarchy menu.

Next, for both LeftGrabber and RightGrabber, remove "Sphere (Mesh Filter)" and "Mesh Renderer" by clicking the gear in the top right corners, and selecting "Remove Component." This will allow the spheres to still remain active, but not be rendered (aka seen).

Now if you run the program, you'll be able to throw balls with your own two hands (kinda)!