Introduction to VR with Unity

Let's begin the creation of our VR Lobby scene with placing the camera and adding a few objects.

To differentiate objects, let's assign them a few materials with different colours.

Let's now import a texture to use as a panoramic background.

To use the texture as a background, we need to create a special material, called a Skybox.

To take advantage of automatic head tracking and stereo rendering, we simply need to add XR SDKs to the Player Settings.

Everything's now setup, let's build our project with Xcode and test it on an iPhone.

To build your project as an "apk" you can push on your Android device, you need to :

1. Go to Unity's Preferences, then External Tools
2. In the Android section, click on Download next to the SDK path, and install Android Studio
3. Then browse for the SDK root folder you just installed.
4. Then install jdk1.8.0_161 from the link provided here in the resources. (Not using the download button).
5. Then browse to /Library/Java/JavaVirtualMachines/jdk1.8.0_161.jdk/Contents/Home.
6. You shouldn't have to, but you can also install android-ndk-r13b using the download button, and browse to its location.
7. Then run Android Studio, and click "Configure".
8. Under SDK Tools, expand the SDKs and uncheck 25.0.3, then click on Apply.

Unity should now be able to build the project.

Everything's now setup, let's build and run our project on Windows or Mac OSX.

Let's begin with importing 360 video files.

Unity's built-in Video Player allows us to playback video files over different objects.

To render the video in our Skybox background, we're going to need an intermediate texture, called a RenderTexture.

Let's begin by adding a few text objects above our selection items.

Using Prefabs allows us to manage similar objects within and across several scenes.

Let's create our 1st C# script and setup MonoDevelop for proper C# standards.

"using", "public", "class", "MonoBehaviour", "void", what does it all mean ?

Let's begin with accessing the object's Renderer component to change the colour of its Material.

Let's use a Gradient property instead of a simple Color.

Calling methods, such gradient.Evaluate(), on every frame, isn't optimal performance wise. Let's use a C# property, to call it only when the position changes.

In this lecture, we're going to reference another object's Transform component, that we'll use later to measure the object's relative position.

Often, there are things we do all the time. Templates are great to keep our code consistent and type it faster.

To avoid loosing track of what's left to do, using Tasks allows us to quickly log remaining tasks with comments using special keywords.

To have a better understanding of Vector maths, we're going to use some visual debug features and draw lines in the Scene View.

If 10 means 1 and 30 means 0.. Wait! It's easy, the Maths helper class does it all for you.

We're now going to add Unity Events to the Object Focus component, so that we can connect its values to other values in the Editor.

While we could ease in and out the interpolation so far linear, we're going to use Unity's built-in Animation Curves, which not only makes it easier but also provide more control.

To easily trigger actions on the object that is the most in focus, we're going to create a new manager script to look after all items.

A Singleton is a design pattern where a component has a unique instance that can easily be accessed at any time.

Methods and members declared static are shared amongst all instances and a lot easier to access from other components.

Let's add events to change the display of the object currently in focus.

If you're using the Cardboard with no Game Controller attached, then a single touch on the screen, using the Cardboard button, it our only option to trigger an event.

Let's make the connections now between the Input touch and the currently highlighted item.

And to wrap this up, we need to properly cancel the trigger when the user looks away.

Now that the input system is in place, let's use it to load another scene.

Let's begin with making sure our gamepad is properly connected and recognised by Unity, using Unity Remote along with the Game Pad.

Unity supports monitoring keyboard keys and game pad buttons in two different ways : using key codes or Input Settings.

Let's add support for key codes first.

Whenever several classes share a fare amount of mechanics, Object Oriented Programming, especially inheritance, allows us to regather all the code in a parent class. This not only makes it easier to implement the mechanics in different components, but it's also easier to maintain.

With all the input mechanics now part of a parent class, implementing it in the Game Pad controller component becomes very simple.

Sometimes it's easier to use Unity's built-in Input class than key codes. Again, using our parent class makes it super easy to implement a different version.

Unless you're using Room Scale Tracking, we have no idea of the cardinal direction the Gyroscope will be initialised in. We're going to use XR features, Scene Manager Events and make the object Persistent so that we "recenter" the orientation on every new scene load event.

When using the Cardboard, you can't preview the XR tracking in the Editor. To work around this and be able to preview things with Unity Remote, we're going to use Unity's Gyroscope native support instead.

When using the Cardboard, the current XR SDKs doesn't provide any feedback in the Editor. Now that we have enabled tracking using the Gyroscope, let's go a little further and add support for stereoscopic rendering.

Let's begin with fixing issues and cleaning the scene a bit.

Now, let's begin with a simple vector looking forward..

Now that we have the heading direction, we're going to find the intersection with the first Collider we hit in the scene.

Layers allow us to ignore sets of objects so that we can look through some categories of objects, such as characters, vehicles, etc.

Colliders, when set as Triggers are usually not meant to block navigation. Let's let the ray cast look through them.

We're now going to "bounce" off walls and obstacles to avoid going to close to them.

Let's use Ray Casting again to find a position on the ground.

Navigation, part of "AI" features of game development, allows us to navigate a 3D world using pre computed navigation data to find the shortest, easiest route from point A to point B. Setting it up in Unity is fairly simple.

With the NavMesh now available, we're going to locate the closest position within the NavMesh, from the ground position we have.

In this lecture we are going to use Pro Builder (free extension available from the Asset Store) to create a 3D cone object.
You can import the Reticle-Cone package if you want to skip this part.

Then we'll code a custom shader to display a 2D reticle texture with alpha, slightly off its render position. This is known as Decal rendering.
You can also use the shader file provided in the resources.

Let's now position the reticle object at the estimated destination, and deactivate it when we don't have one.

We're now going to set up a NavMesh Agent, and give it the target location for destination, with a method we can easily test in the Editor.

With this new component and the previous components we've made in earlier chapters, we're now going to be able to put together a First Person Camera Navigation system.

When using a VR device, such as the HTC Vive, we can track controllers positions and rotations. Let's use this to aim for a target position with the controller instead of the Camera.

Sometimes we want to force disable room scale tracking. Useful in car racing games for example, you don't want the player's head to come out the car's rooftop.

Let's begin with detecting when an object enters and leaves the Trigger Collider.

It's now as simple as changing the state of the Animator parameter when an object enters and leaves the Trigger.

As we may have other objects in the scene, we may want to filter the trigger so that it only triggers the Animation with a given object. We can easily do this with tags.

Let's add a few optimisations to make the component event more generic, and apply the changes made to all doors.

We can also use Unity Events, to trigger any action.