Godot Tutorials -- 3D Ray Casting Video Lecture | Godot Game: Learn and Master - Game Development

hi this is Mike again from scratch
welcome to another video tutorial this
one actually comes in direct response to
a reader request or actually a viewer
request asking me they've got a setting
in their scene basically if there's
something that gets in between their
camera and the object they're looking at
they want to make that object invisible
and they want to know how to go about
doing this in Godot they were on the
right track with ray casting and that's
exactly what you do it's a matter of how
you go about doing it so that's what
we're looking at today we're looking at
ray casting in 3d in Goodell now ray
casting is basically just shooting a
beam off from the scene and seeing what
it hits it's used all the time
ai often uses Ray casting for or
figuring out what's in front of it as
you see here we're using it for the
camera to determine visibility etc Ray
casts are pretty much the way you see in
the scene so it's an important thing and
it's not immediately obvious how you do
this in Godot so that's exactly what
we're going to look at today now you'll
notice if you've been following the
tutorial series to this point Godot is
gonna look a little bit different that's
because I just switched up to the beta
of the second of Godot 2.0 which should
be out any day now so all of the stuff
that I do here will work in an earlier
version of Godot so things are gonna be
in slightly different places so don't
worry too much if it looks jarring ly
different than what you've got it's just
the newer version and again although
this functionality all of the code
everything will work in a previous
version speaking of the code there's a
text-based version of this tutorial
variable on game from scratch I will
link it in the comments down below
alright so let's continue on first
things first we're gonna need to go
ahead and create a project we'll call
this C colon slash Tim and browse let's
go ahead and hey you see colon slash
yeah and let's create a folder called
raycast
good dope open and create open up our
new project and here we go so welcome to
Godot - as I said this should be out any
day now but if you want if you build
from sources this is what you will get
right now so let's go ahead we'll add
note or scene
and again I assume you've watched all
the previous tutorials in the series so
I don't explain anything I've already
covered if I do something that you don't
follow along
check the earlier tutorials in the scene
it's or in the series that's probably
covered somewhere so what we're gonna
have to do is each item that's gonna be
potentially hit by a red house needs to
be a physics object needs to be
available to the physics server so that
it actually can do the testing so what
I'm gonna do is I'm gonna create a very
simple scene made up of cubes in each of
those cubes is going to have rigidbody
I with gravity turned off we can also
accomplish the same thing by basically
making them static objects but in this
case I'm gonna go revert your body with
no gravity so each one's gonna be a
rigidbody contain a test cube and then a
bounding volume or a collision surface
we covered this already in a previous
tutorial on 3d so let me just quickly go
ahead and create them so first things
first means our rigidbody and then it
has a test cube and it has polygons no
collision shape okay
so we have our rigidbody sets up it's
got the test cube so we can actually see
something and we have to find the shape
the shape needs to be a box shape like
so I so now we want to do go ahead and
create that hierarchy again here we'll
just do a copy and I'll call this guy
rigidbody to just so we're staying
consistent with the text version so as
you can see we've got a test queue of a
collision shape a test cube in a
collision shape now I'm gonna take the
second one and let's move our camera
slightly so we're gonna move it out and
up like so now we need a camera for a
scene this is where the rigidbody is
going sorry the test array or that the
raycast is going to originate from our
camera and through both of these objects
so now let's go ahead and add a camera
to our scene so and now our camera
before we move it we want to attach the
raycast so raycast
now you'll notice there are 2d and 3d
versions of everything we're dealing
with we obviously want the
on 2d version so here's our camera we'll
move it up and over like so
oops I'll do that select the actual
camera move it up over like so let's
angle it down so we're seeing through
our one object and the other object like
so so there's the camera angle now we
want to go ahead and take our right
Caston we're gonna extend the raycast
out now the raycast casts too and we're
gonna change this we're not gonna go on
negative one instead we're gonna go with
the z axis and this is gonna be the
length of your calf so I'm gonna go over
to eleven and you'll see there is our
array now you can set that value to
whatever you wish now the nice thing is
since I moved both of these I did the
translations after creation so that the
child is taking all the translations
from the parent making this math very
simple for us so if we wanted a smaller
length rag we could obviously set this
to like so and you see the end result it
doesn't particularly matter in this case
though it has to hit this guy it has to
hit rigidbody too because that's what
we're going to test against so what we
want to do here is test to see if
anything happens between this camera and
the origin 0 0 1 0 and how are we gonna
do this well we're gonna do this
obviously with some code so your scene
is set up now we have our proper we have
two entities rigid bodies defined so
they can be hit with a collision now we
just need to check the raycast now in
order to do this let's go ahead and add
a script to our camera
so you heard of the gibberish Excel all
right so first things first let us
define a variable for RA in our array
equals get node ray cast right so we're
just basically gonna get a reference to
this guy just for convenience sake next
thing up
we have an update loop so handle process
equals true oops
so now let's define our process variable
now uh I'm gonna add some logic right
away so we can pan our camera around dot
is key pressed key up
kiyo all right missed by one keep up and
if it is we will just take ourselves
translate vector three and we'll just
move very slightly up the y-axis this
way our camera can move and it'll move
our attached ray which in turn will
cause a hit and not yet so we can
actually see that this is actually
working
so now let's copy and paste here and
handle the same thing for down just
switch that up to a minus and we're good
to go
now that that handled let us go ahead
and check with our right so first thing
we do is check to see if our ray dot is
all right all these have some kind of an
error let's see what are you pissed off
at this alright stop all typos should be
happy yes sir
if is enabled and Ray dot is colliding
so this is gonna check to see if the Ray
is currently hitting something or not
now that first part is key this means
that the ring is currently actually on
and right now it actually isn't so let's
go on back here and in the property set
enable to true and I'm back over to our
scripted so there is our logic there so
we're gonna check that it is enabled
which we obviously just saw it that yes
it is and I'm gonna do some gross
hackery here just for the demonstration
purposes your game logic would obviously
be much less hard-coded than what I'm
about to do but this keeps it short and
simple so first we're gonna go collided
with object equals and then Ray dot get
Collider so colliders gonna take a
reference to what was hit now obviously
this was only going to be true if we
currently hit something so this will
always be true now if it oh yeah so that
checks to see what is being collided
with so now we're gonna we know that
we've got an object of some kind we
actually know what it is we're gonna
cheat a little bit so collided with
object dot get name equals rigid body
too so if we are hitting our second
rigid body hide it like so so basically
if the Ray is hitting it make it
miserable otherwise and here's the
otherwise and here's some more girls
hackery
rigid body - Wow so there is our logic
basically we check to see if our array
collides with anything if it does we
check the name of what it was and what
it was is determined by the get collider
and we take that reference if it is in
fact the one we think it might be we go
ahead and hide it otherwise we make sure
that that thing is actually visible this
logic kind of sucks it's gonna cause
some flickering but for the most part
it's going to demonstrate what we want
so I'm gonna go ahead and save that like
so and going back set up our scene like
so I always forget something but I don't
know if I have now go ahead and run this
oh yeah I did forget something
prathab from gravity off so let's head
on back rigidbody 1 gravity scale zip
rigidbody to gravity scale is zip make
sure that stuff for the first one it did
alright let's go ahead and run that
again so now we've got obviously only
the one body is visible because this
collision is true so let's hit the up
arrow until our ray
all right where's my logic going around
here one second interesting and I'm not
exactly sure what the logic is here but
when I truncated this down to minus 500
is 6 I had so that wasn't passing all
the way through it's causing this
collision not to actually trigger so
make sure your cast 2 goes all the way
through and to the point so when I made
the shorter version for some reason it's
not triggering the actual condition so
I'm not exactly sure what's going on
there I'll have to research it maybe
I'll put it in the comments below when I
figure out what's going on but now with
that actually in place here let me show
you what happens without a collision we
have our two objects likes 1 in front of
the other and our camera on arrow is
going through so now take that out put
that back in so in the event that an
occlusion occurs we hide it so you can
see we're hiding it not hiding our logic
is kind of poor because we're basically
showing hide show and hide show and hide
over and over and over again but you'll
see once that's not hitting its shown
eye etc so that is basically a ray cast
in action now again our logic isn't
isn't beautiful you would probably do
something much much cleaner than this
but that is essentially that is
recasting how ray casting can be used to
detect things in the scene you'll notice
it's returning the first collision it
achieves now let's go ahead and show the
ability to do this completely in code so
here we're actually we had to create
this ray in the scene this guy right
here we created as a node now you can do
this entirely code based and let's look
at that instead now this requires a
little bit of a logic change we're gonna
be using the built in physics server now
the physics server can only be pulled 1
the call we need to make a space get get
direct state and that can only be called
during an integrated forces or fixed
Cesco so what we need to do is just set
set process instead to set big process
like so and then did it up here like
that and you know we reuse the same
logic for up and down just instead of
using the Ray like we did here and I'll
replace this code and we're gonna create
the Ray instead using code and as I said
earlier we're gonna use the physics
server so first we're gonna get this
direct state from the physics server so
physics server and then space get a
direct estate this needs to be passed
from rural to IP we can get the world ID
from get world dot get space so he needs
a space ID so like that so now we got
the direct state of the physics world
we're gonna check for collisions in it
so direct
grant from var call collisions this is a
dictionary that has returned from direct
state dot intersect ray and we're gonna
send a ray from our current location of
our camera to the origin like so so
basically we're just creating the line
from our camera to the origin or zero
zero zero in our world and we're
checking for collisions and if there are
collisions that dictionary will have a
size so if collisions dot size and
collisions as it sets the dictionary one
of the values of the click in the
dictionary it's gonna be position and
another one is collider collider is the
entity that gets collided with so we're
gonna go ahead and check collider dot
nem equals rigid body to so and if that
is the case that means we collided with
our rigidbody two and we'll get our
entity again so this is the object
collided with inside the dictionary just
go ahead and hide it
otherwise a little bit more gross
hackery like so so this is the
programmatic way of accomplishing the
same thing mine if the : go ahead and
run that and as you see not being
intersected intersected being hidden and
quickly shown again the logic kind of
sucks you would rather use a talk and no
intersection intersection no
intersection so that is raycasting good
oh very very handy very very useful
things basically if you are going to be
looking for entities in the scene
checking visibility seeing if the player
can see something else without something
in between colliding that is what you
use you use raycast
now keep in mind 2d that's the same
functionality almost the exact same
mannerisms except for a little bit
easier to use actually and the names and
with 2d so it's physics server Tunney
it's ray Kasten 2d etc but otherwise
it's basically the same logic so that's
about it that's all we're going to cover
for today I hope that was useful once
again there is a text-based version I
will link it down below I will also link
to the entire series itself both here on
YouTube and on game from scratch hope
you enjoyed that see you later bye