python - Ray and square/rectangle intersection in 3D

Question

Hei. Are making a game and are looking for a ray intersection onto a square or a rectangle only in 3D space. Have search the web and found many solutions but nothing i can understand have a line and line segment intersection script in 2D but i cant figure out have to make it 3D. It is not important from what side it intersect the square or rectangle but it must be able to retrive the point of intersection vector so that later can be tested for distance to se if it occurred before or after other intersections on the same ray intersection.

Any examples in python or other similar scripting languages will be greatly appreciated

Edit: Dont know have to modify the 2D to show an exaple but made a new and posting both.

//this is the exaple it test a ray onto a plane then look to se if that point is in the rectangle and saves it to test for distanse later
list Faces; //triangle faces
list Points; //

vector FindPoint(){
    //calcute the point of intersection onto the plane and returns it
    //if it can intersect
    //else return ZERO_VECTOR
}

integer point-in-quadrilateral(){
    //return 1 if the point is in the rectangular on the plane
    //else return 0
}

default{

    state_entry(){
        integer n = (Faces != []); //return number of elements
        integer x = 0;
        while(x < n){
            vector intersection = FindPoint( FromList(Faces, x) ); //take     out a element and runs it trough the function
            if(intersection != ZERO_VECTOR){
                integer test = point-in-quadrilateral( FromList(Faces,     x) ); //find out if the point is in rectangular
                if(test == 1){ //if so
                    Points += intersection; //save the point
                }
            }
            ++x;
        }

        float first; //the distanse to the box intersection
        integer l = (Points != []);
        integer d;
        while(d < l){
            if(Dist( FromList(Points, d) ) < first) //if the new distanse     is less then first
                return 0; //then end script
            ++d;
        }
    }

}


//this is the 2D version
vector lineIntersection(vector one, vector two, vector three, vector four){
float bx = two.x - one.x;
float by = two.y - one.y;
float dx = four.x - three.x;
float dy = four.y - three.y; 
float b_dot_d_perp = bx*dy - by*dx;
if(b_dot_d_perp == 0.0) {
    return ZERO_VECTOR;
}
float cx = three.x-one.x; 
float cy = three.y-one.y;
float t = (cx*dy - cy*dx) / b_dot_d_perp; 
if(LineSeg){ //if true tests for line segment
    if((t < 0.0) || (t > 1.0)){
        return ZERO_VECTOR;
    }
    float u = (cx * by - cy * bx) / b_dot_d_perp;
    if((u < 0.0) || (u > 1.0)) {
        return ZERO_VECTOR;
    }
}

return <one.x+t*bx, one.y+t*by, 0.0>; 

}

Answer 1

The solution is very easy when you define a ray with a point(= vector) and a direction vector, and the rectangle with a point(= vector) and two vectors representing the sides.

Suppose the ray is defined as R0 + t * D, where R0 is the origin of the ray, D is an unit vector representing its direction and t is its length.

The rectangle can be represented with a corner point P0, and two vectors S1 and S2 which should represent the sides (their length being equal to the length of the sides). You will need another vector N normal to its surface, which is equal to the unit vector along the cross product of S1 and S2.

Now, assume the ray intersects the rect at P. Then, the direction of the ray, D must make a nonzero angle with the normal N. This can be verified by checking D.N < 0.

To find the intersection point, assume P = R0 + a * D (the point must be on the ray). You need to find the value of a now. Find the vector P0P. This must be perpendicular to N, which means P0P.N = 0 which reduces to a = ((P0 - R0).N) / (D.N).

Now you need to check if the point is inside the rect or not. To do this, take projection Q1 of P0P along S1 and Q2 of P0P along S2. The condition for the point being inside is then 0 <= length(Q1) <= length(S1) and 0 <= length(Q2) <= length(S2).

This method is appropriate for any type of parallelograms, not only for rectangles.