[MUSIC]

We're going to write a script that allows us to pick up the basketball and throw it.

When it's stated in a sentence like that, it sounds like a pretty simple and

intuitive task, however we have to write code that works every step of the way.

The script will be attached to each controller and

needs to first detect if the controller is intersecting with an object.

Then if the controllers intersecting it also needs to detect if the player

is holding down the trigger button on the controller to pick up the object.

If the controller is intersecting an object and the player is

holding down the trigger, then we can attach the object to the controller.

Once we've attached the object to the controller,

we need to be able to release the object.

Like I said, it's a little bit more complicated than it sounds, so

let's get started by creating the script and detecting intersections.

In the project window, navigate to the scripts folder and create a new script.

And call it controller interaction.

Then in the higher key select, the left and

right controller and then drag the controller interaction

script from the project window to the inspector.

Then open the script for editing.

First delete these start and update methods as we will not need them.

Next we need to get the controllers Steam VR tracked object component and

figure out which controller the script is actually attached to.

To kick that off, let's create some of the variables we're going to need.

I'll type this out and then explain it, so

inside the class here we'll create some variables.

First will be a private steam VR _TrackedObject.

And we'll just call that lowercase tracts a case Object.

And then we'll create a private SteamVR_Controller.Device, and

we will call this device and

we'll create a private rigid body and call this attach point.

And then finally, we'll create a private FixedJoint

and call that variable, fixedJoint.

The SteamVR TrackedObject class is part

of the SteamVR plugin and it contains an index will need

to determine which object in the tracking volume is being used.

The SteamVR Controller.Device is an object to which will

assign the controller once we've used the index to determine which one we're using.

That's a little confusing but

it will make more sense when we write the rest of the script.

The attach point is a rigid body and

we'll use this fixed joint object to connect the basketball to the controller.

Again, this will make more sense when we actually use these variables.

Now let's use the Awake method to get some of these components and

assign them to our variables.

It's all create some space to work here and then I'll type, void Awake.

And then, first, we need to get the controller components.

So let's do that.

Tract object.

It's going to be equal to get components,

Steam VR TrackedObject.

So that component and

then the attach point is going to be the rigidBody components so let's get that.

So we'll get the rigidBody component that's attached to this game object.

Using awake instead of star in this case isn't totally necessary but awake executes

earlier than start which can be helpful if this project becomes more complex and

needs these components to be accessible by other scripts in their start method.

Again, not the case here but it's good to think ahead.

That's most of the set up will need to get going.

However, without any of these variables wee can

actually detect intersections right away.

Using the on trigger stay message.

So let's type that out.

Just below awake here,

we'll type void OnTriggerStay and

inside we'll pass, Collider other.

And this will execute any time this trigger

Collider intersects with another Collider.

But how will we know this is working correctly?

We could log output to the console but

we won't be able to see it until we take off the VR headset and go back to unity.

It would be a lot more fun to get some visual feedback in the game.

So let's grab the collider named Other.

Get its game object and set its material color to a totally random color.

So inside here I'll type other to get the other Collider.

Take game object to get the game object that the other Collider is attached to or

use gets component.Renderer to get

the render that's attached to this game object, so this is usually a mesh render

and then from the mesh render we can get its assigned material and

on the material, we can get its materials color.

And this is what we want to set to a random color value

any time the controller intersects with the object.

So it will create a new color here.

And we're going to set its R.G.B. values.

Randomly so will type Random.Range for

the red value and this needs to be a value between zero and one.

So we'll just pick a random float value between zero and one.

And then we just need to do this for green and blue.

So I'll just paste this two more times here separating with comments.

And then I'll break this out into separate lines just so it's easier to read here.

So let's do that, And then I'll format this so

that we can see what's going on.

There we go.

So what are we doing here, we're taking the Collider other, getting its game

object, getting backgame objects renderer, getting that renders material,

getting that material's color, and then we're setting that color for

this game object to A random color and

we're doing this every time on trigger stay is called which will be constantly.

So the object that gets intersected will just flash to random colors.

In production, you wouldn't ever want to use the GetComponent method like

this because it's a fairly expensive line of code and

in this case, it's being called many times per second.

We'll take this code out when we're done with it but for

testing purposes, this will give us some nice visual feedback, save the script.

Return to unity.

Save the scene.

Hit the play button and then jump and in the V.R..

So now when you load up the game.

You should see your controllers and

you should also see the basketball sitting here on the court.

And you may have noticed that your basketball may have already changed colors

and it's also possible that the floor of your court has changed colors as well.

And this just depends on how the controllers were first initialized

when the tracking volume was started at the start of the game

because the controllers will change the color of any object they intersect and

it's possible that the controllers may have already intersected the floor or

may have already intersected the basketball.

So let's see if this works and

it looks like it does when we intersect the controller.

With the basketball, will randomly change colors and

when we remove the controller from the basketball,

it will stick on whatever the last randomly selected color might have been.

So now that we know this is working

in that we can detect these intersections we're ready to move on.