We're able to pick up objects but once we do, they're stuck to the controller.

Let's raise some code that will allow us to release the ball

after it's been picked up.

So let's switch back to the controller interaction script and,

in here, we need to release objects.

The player will be able to release objects by simply releasing the trigger

button on the controller after they've press down to pick up an object.

The best place to check for this is inside the fixed update method because,

at any moment, the player could release the trigger button so

we need to check every physics update.

In addition, they need to be holding an object in the first place in order for

the object to be released.

We can test for that by checking whether or not the fixed joint variable is null.

So, let's write that out.

So, just after we've done the device assignment,

we'll type another big comment here to just describe this general area of code.

We'll say here is where we are going to release objects.

So again, if there's a fixed joint attached and

the trigger button is deactivated.

So we'll type that out in code if (fixedJoint),

lowercase F, uppercase J, is not equal to null,

which means it is set and device.GetTouchUp,

meaning that the button is released.

So we want that button to be SteamVR_Controller.Button.Mask.Trigger.

So if both of these are true, then we will execute some code here.

Great, now, how should we release the object?

Well, in order to play basketball or throw any object,

you need to be able to transfer your energy into the object.

Unity doesn't have the physics concept of kinetic energy but

it does have velocity and angular velocity.

The velocity describes the speed of an object's translation in a given direction

and angular velocity is the speed and direction of an object's rotation.

We'll need to assign that information to the ball through its rigid body so

let's grab that first.

[SOUND] First, get the rigid

body on the fixed joint's gameobject.

We'll say Rigidbody and we'll just create a new rigid body here.

[SOUND]

fixedJoint.gameObject.GetComponent<

Rigidbody>, and

that will assign it.

Now, we want to detach the ball from the controller.

We can do that by destroying the fixed joint component.

This will also set the fixed joint variable to null.

That way, the if statement to pick up objects in the OnTriggerStay

method will be able to execute again the next time the player picks up the ball

because it checks if the fixed joint variable is null.

So, let's type that out and then I’ll explain it a bit more.

So just after this line.

I want to destroy the fixed joint.

And we're going to say DestroyImmediate(fixedJoint).

So in this line, we're destroying the fixed joint component

by calling destroy immediate on the fixed joint variable.

But instead of using the destroy method like we have in previous courses,

we're using the DestroyImmediate method.

DestroyImmediate will nullify the component when this line of code

is executed and that's necessary because we're going to set the velocity next.

If we just used destroy, like normal, the fixed joint wouldn't be destroyed until

the end of the frame and the velocity won't be transferred because the game

object is still being controlled by the fixed joint rather than the rigidBody.

The Unity documentation discourages using DestroyImmediate in

most cases but, in this code, we do need the component to be destroyed right away.

For a link to the Unity documentation on DestroyImmediate,

see the notes associated with this video.

So finally, let's transfer the velocity to the rigid body.

I'll type this out and then explain it.

So I'll just scroll down a little bit here and,

just after DestroyImmediate,

I'm going to set the Rigidbody's velocity and

the angular velocity to the controller's values.

So we'll take that Rigid body that we just created and

grabbed from the fixed joint's game object and

we'll say rigidBody.velocity is equal to the device.velocity and

then rigidBody.angularVelocity is

equal to the device.angularVelocity.

So in this code, we're taking the velocity and angular velocity

from the device class and the device variable,

and we're applying it to the objects rigidBody.

This will make the basketball feel like it's moving and

spinning at an appropriate speed when we release the ball, enabling

us to throw the ball and even dribble it in the way that you would expect.

So save the script, return to Unity and

then play the game, and I will see you in VR.

So now if we pick up the ball, we can release it and

it will fall to the ground, and we can pick it back up.

However, if we throw it outside the tracking

volume, we don't have any way to retrieve it.

We also don't have any way to interact with the scoreboard or start the game.

In the next video, we'll fix these problems.