Distance to plane

Now that it's clear what a plane is, let's go back to the dot product.The dot product between aunit vector and anypoint in space(yes, this time we do dot product between vector and position), returnsthedistance from the point to the plane:

vardistance=normal.dot(point)

vardistance=normal.Dot(point);

But not just the absolute distance, if the point is in the negative halfspace the distance will be negative, too:

This allows us to tell which side of the plane a point is.

Away from the origin

I know what you are thinking! So far this is nice, butreal planes areeverywhere in space, not only passing through the origin. You want realplane action and you want itnow.

Remember that planes not only split space in two, but they also havepolarity. This means that it is possible to have perfectly overlappingplanes, but their negative and positive half-spaces are swapped.

With this in mind, let's describe a full plane as anormalN and adistance from the origin scalarD. Thus, our plane is representedby N and D. For example:

For 3D math, Godot provides aPlanebuilt-in type that handles this.

Basically, N and D can represent any plane in space, be it for 2D or 3D(depending on the amount of dimensions of N) and the math is the samefor both. It's the same as before, but D is the distance from the originto the plane, travelling in N direction. As an example, imagine you wantto reach a point in the plane, you will just do:

varpoint_in_plane=N*D

varpointInPlane=N*D;

This will stretch (resize) the normal vector and make it touch theplane. This math might seem confusing, but it's actually much simplerthan it seems. If we want to tell, again, the distance from the point tothe plane, we do the same but adjusting for distance:

vardistance=N.dot(point)-D

vardistance=N.Dot(point)-D;

The same thing, using a built-in function:

vardistance=plane.distance_to(point)

vardistance=plane.DistanceTo(point);

This will, again, return either a positive or negative distance.

Flipping the polarity of the plane can be done by negating bothN and D. This will result in a plane in the same position, but withinverted negative and positive half spaces:

N=-ND=-D

N=-N;D=-D;

Godot also implements this operator inPlane.So, using the format below will work as expected:

varinverted_plane=-plane

varinvertedPlane=-plane;

So, remember, the plane's main practical use is that we cancalculate the distance to it. So, when is it useful to calculate thedistance from a point to a plane? Let's see some examples.

Constructing a plane in 2D

Planes clearly don't come out of nowhere, so they must be built.Constructing them in 2D is easy, this can be done from either a normal(unit vector) and a point, or from two points in space.

In the case of a normal and a point, most of the work is done, as thenormal is already computed, so calculate D from the dot product ofthe normal and the point.

varN=normalvarD=normal.dot(point)

varN=normal;varD=normal.Dot(point);

For two points in space, there are actually two planes that pass throughthem, sharing the same space but with normal pointing to the oppositedirections. To compute the normal from the two points, the directionvector must be obtained first, and then it needs to be rotated 90degrees to either side:

# Calculate vector from `a` to `b`.vardvec=point_a.direction_to(point_b)# Rotate 90 degrees.varnormal=Vector2(dvec.y,-dvec.x)# Alternatively (depending the desired side of the normal):# var normal = Vector2(-dvec.y, dvec.x)

// Calculate vector from `a` to `b`.vardvec=pointA.DirectionTo(pointB);// Rotate 90 degrees.varnormal=newVector2(dvec.Y,-dvec.X);// Alternatively (depending the desired side of the normal):// var normal = new Vector2(-dvec.Y, dvec.X);

The rest is the same as the previous example. Either point_a orpoint_b will work, as they are in the same plane:

varN=normalvarD=normal.dot(point_a)# this works the same# var D = normal.dot(point_b)

varN=normal;varD=normal.Dot(pointA);// this works the same// var D = normal.Dot(pointB);

Doing the same in 3D is a little more complex and is explainedfurther down.

Some examples of planes

Here is an example of what planes are useful for. Imagine you haveaconvexpolygon. For example, a rectangle, a trapezoid, a triangle, or just anypolygon where no faces bend inwards.

For every segment of the polygon, we compute the plane that passes bythat segment. Once we have the list of planes, we can do neat things,for example checking if a point is inside the polygon.

We go through all planes, if we can find a plane where the distance tothe point is positive, then the point is outside the polygon. If wecan't, then the point is inside.

Code should be something like this:

varinside=trueforpinplanes:# check if distance to plane is positiveif(p.distance_to(point)>0):inside=falsebreak# with one that fails, it's enough

varinside=true;foreach(varpinplanes){// check if distance to plane is positiveif(p.DistanceTo(point)>0){inside=false;break;// with one that fails, it's enough}}

Pretty cool, huh? But this gets much better! With a little more effort,similar logic will let us know when two convex polygons are overlappingtoo. This is called the Separating Axis Theorem (or SAT) and mostphysics engines use this to detect collision.

With a point, just checking if a planereturns a positive distance is enough to tell if the point is outside.With another polygon, we must find a plane wherealltheotherpolygonpoints return a positive distance to it. This check isperformed with the planes of A against the points of B, and then withthe planes of B against the points of A:

Code should be something like this:

varoverlapping=trueforpinplanes_of_A:varall_out=trueforvinpoints_of_B:if(p.distance_to(v)<0):all_out=falsebreakif(all_out):# a separating plane was found# do not continue testingoverlapping=falsebreakif(overlapping):# only do this check if no separating plane# was found in planes of Aforpinplanes_of_B:varall_out=trueforvinpoints_of_A:if(p.distance_to(v)<0):all_out=falsebreakif(all_out):overlapping=falsebreakif(overlapping):print("Polygons Collided!")

varoverlapping=true;foreach(PlaneplaneinplanesOfA){varallOut=true;foreach(Vector3pointinpointsOfB){if(plane.DistanceTo(point)<0){allOut=false;break;}}if(allOut){// a separating plane was found// do not continue testingoverlapping=false;break;}}if(overlapping){// only do this check if no separating plane// was found in planes of Aforeach(PlaneplaneinplanesOfB){varallOut=true;foreach(Vector3pointinpointsOfA){if(plane.DistanceTo(point)<0){allOut=false;break;}}if(allOut){overlapping=false;break;}}}if(overlapping){GD.Print("Polygons Collided!");}

As you can see, planes are quite useful, and this is the tip of theiceberg. You might be wondering what happens with non convex polygons.This is usually just handled by splitting the concave polygon intosmaller convex polygons, or using a technique such as BSP (which is notused much nowadays).