CODEWITHSUNDEEP
java3dgeometryraytracing
seesharper
seesharper

Reputation: 147

Is this raycasting algorithm correct? Is this the proper way to test the intersection of a line/ray and cubes?

I am building a LWJGL program that test to see if a cube is in front of the camera. I think it is working, but I am getting a ton of different numbers. I am thinking that it is because the planes go on forever, and they are not finite squares. What would I do to go about fixing this? (I have also noticed that my code is fairly slow, what could be causing this???)

Here is my intersection code:

public static float getCubeInteresection(Cube b, Vector3f camera, Vector3f lookat)
{
    Vector3f l = b.Location;
    float boxs = 0.5f;
    Plane3f[] bplanes = Plane3f.getBoxDefaults(l, boxs);
    Vector3f result = null;
    for (int t = 0; t < bplanes.length; t++)
    {
        Vector3f raytrace = getIntersection(camera, lookat,bplanes[t].Point0,bplanes[t].Point1,bplanes[t].Point2);
        if (raytrace != null)
        {
            result = raytrace;
            break;
        }
    }
    if (result == null)
        return -1.0f; //not hit, waste of time... lol
    float x = (float) Math.pow(result.x - camera.x, 2);
    float y = (float) Math.pow(result.y - camera.y, 2);
    float z = (float) Math.pow(result.z - camera.z, 2);
    float dist = (float) Math.sqrt(x + y + z);
    return dist;
}
private static Vector3f getIntersection(Vector3f line12, Vector3f line22,Vector3f plane12, Vector3f plane22, Vector3f plane32)
{
    javax.vecmath.Vector3f plane1 = new javax.vecmath.Vector3f(plane12.x,plane12.y,plane12.z);
    javax.vecmath.Vector3f plane2 = new javax.vecmath.Vector3f(plane22.x,plane22.y,plane22.z);
    javax.vecmath.Vector3f plane3 = new javax.vecmath.Vector3f(plane32.x,plane32.y,plane32.z);
    javax.vecmath.Vector3f line1 = new javax.vecmath.Vector3f(line12.x,line12.y,line12.z);
    javax.vecmath.Vector3f line2 = new javax.vecmath.Vector3f(line22.x,line22.y,line22.z);
    javax.vecmath.Vector3f p1 = new javax.vecmath.Vector3f(plane1);
    javax.vecmath.Vector3f p2 = new javax.vecmath.Vector3f(plane2);
    javax.vecmath.Vector3f p3 = new javax.vecmath.Vector3f(plane3);
    javax.vecmath.Vector3f p2minusp1 = new javax.vecmath.Vector3f(p2);
    p2minusp1.sub(p1);
    javax.vecmath.Vector3f p3minusp1 = new javax.vecmath.Vector3f(p3);
    p3minusp1.sub(p1);
    javax.vecmath.Vector3f normal = new javax.vecmath.Vector3f();
    normal.cross(p2minusp1, p3minusp1);
    double d = -p1.dot(normal);
    javax.vecmath.Vector3f i1 = new javax.vecmath.Vector3f(line1);
    javax.vecmath.Vector3f direction = new javax.vecmath.Vector3f(line1);
    direction.sub(line2);
    double dot = direction.dot(normal);
    if (dot == 0) return null;
    double t = (-d - i1.dot(normal)) / (dot);
    javax.vecmath.Vector3f intersection = new javax.vecmath.Vector3f(line1);
    javax.vecmath.Vector3f scaledDirection = new javax.vecmath.Vector3f(direction);
    float scalent = (float)t;
    scaledDirection.scale(scalent);
    intersection.add(scaledDirection);
    javax.vecmath.Vector3f intersectionPoint = new javax.vecmath.Vector3f(intersection);
    return new Vector3f(intersectionPoint.x,intersectionPoint.y,intersectionPoint.z);
}

And here is my Cube code:

import org.lwjgl.util.vector.Vector3f;

public class Plane3f
{
public Vector3f Point0;
public Vector3f Point1;
public Vector3f Point2;
public Plane3f(Vector3f p0, Vector3f p1, Vector3f p2)
{
    Point0 = p0;
    Point1 = p1;
    Point2 = p2;
}
public static Plane3f[] getBoxDefaults(Vector3f l, float boxs)
{
    Plane3f[] plane = new Plane3f[24];
    Vector3f p0p0 = new Vector3f(-boxs +  l.x, -boxs +  l.y, boxs +  l.z);
    Vector3f p0p1 = new Vector3f(boxs +  l.x, -boxs +  l.y, boxs +  l.z);
    Vector3f p0p2 = new Vector3f(boxs +  l.x, boxs +  l.y, boxs +  l.z);
    //Vector3f p0p3 = new Vector3f(-boxs +  l.x, boxs +  l.y, boxs +  l.z);
    Plane3f p0 = new Plane3f(p0p0, p0p1, p0p2);

    Vector3f p1p0 = new Vector3f(-boxs +  l.x, -boxs +  l.y, -boxs +  l.z);
    Vector3f p1p1 = new Vector3f(-boxs +  l.x, boxs +  l.y, -boxs +  l.z);
    Vector3f p1p2 = new Vector3f(boxs +  l.x, boxs +  l.y, -boxs +  l.z);
    //Vector3f p1p3 = new Vector3f(boxs +  l.x, -boxs +  l.y, -boxs +  l.z);
    Plane3f p1 = new Plane3f(p1p0, p1p1, p1p2);

    Vector3f p2p0 = new Vector3f(-boxs +  l.x, boxs +  l.y, -boxs +  l.z);
    Vector3f p2p1 = new Vector3f(-boxs +  l.x, boxs +  l.y, boxs +  l.z);
    Vector3f p2p2 = new Vector3f(boxs +  l.x, boxs +  l.y, boxs +  l.z);
    //Vector3f p2p3 = new Vector3f(boxs +  l.x, boxs +  l.y, -boxs +  l.z);
    Plane3f p2 = new Plane3f(p2p0, p2p1, p2p2);

    Vector3f p3p0 = new Vector3f(-boxs +  l.x, -boxs +  l.y, -boxs +  l.z);
    Vector3f p3p1 = new Vector3f(boxs +  l.x, -boxs +  l.y, -boxs +  l.z);
    Vector3f p3p2 = new Vector3f(boxs +  l.x, -boxs +  l.y, boxs +  l.z);
    Plane3f p3 = new Plane3f(p3p0, p3p1, p3p2);

    Vector3f p4p0 = new Vector3f(boxs +  l.x, -boxs +  l.y, -boxs +  l.z);
    Vector3f p4p1 = new Vector3f(boxs +  l.x, boxs +  l.y, -boxs +  l.z);
    Vector3f p4p2 = new Vector3f(boxs +  l.x, boxs +  l.y, boxs +  l.z);
    Plane3f p4 = new Plane3f(p4p0, p4p1, p4p2);

    Vector3f p5p0 = new Vector3f(-boxs +  l.x, -boxs +  l.y, -boxs +  l.z);
    Vector3f p5p1 = new Vector3f(-boxs +  l.x, -boxs +  l.y, boxs +  l.z);
    Vector3f p5p2 = new Vector3f(-boxs +  l.x, boxs +  l.y, boxs +  l.z);
    Plane3f p5 = new Plane3f(p5p0, p5p1, p5p2);
    plane[0] = p0;
    plane[1] = p1;
    plane[2] = p2;
    plane[3] = p3;
    plane[4] = p4;
    plane[5] = p5;
    return plane;
}

The output of the console:

camera: (0.0,0.0,6.0)LookAt (end of line): (124.33239,274.9127,-1000.5496) Distance(returned from "getBlockInteresection"): 2.6099026 cube location: 6,7,8

Upvotes: 2

Views: 1859

Answers (1)

Sean
Sean

Reputation: 254

I had to deal with this with my game, however raycasting and frustum culling are two different things. Frustum culling is typically more expensive to perform on a large amount of objects, and also less accurate, but it is much simpler and will probably be fine for your program.

If you just need to know if the cube is in the viewport, you can use the function in the link. This will test if the cube is inside your view frustum, not just in front of it, so if it's in front but too far off to the side it will return false.

Otherwise, you will need to write a raycasting algorithm using a fresh glortho and gldeproject.

http://www.crownandcutlass.com/features/technicaldetails/frustum.html

Upvotes: 1

Related Questions