implemented AABB-line intersection algorithm

Author: codeanticode

mode/libraries/vr/examples/IntersectsBox/IntersectsBox.pde

@@ -15,11 +15,10 @@ void draw() {
 
   cam.setPosition(0, 0, 200);
   push();
-  angleMode(DEGREES);
-  rotateZ(rotAngle);
+  rotateZ(radians(rotAngle));
   translate(100, 0, 0);
   fill(255, 0, 0);
-  if (intersectsBox(50)) {
+  if (intersectsBox(50, 0, 0)) {
     rotAngle += rotSpeed;
     fill(0, 0, 255);
   }

mode/libraries/vr/src/processing/vr/VRGraphics.java

@@ -56,7 +56,19 @@ public class VRGraphics extends PGraphics3D {
   private Viewport eyeViewport;
   private float[] eyeView;
   private float[] eyePerspective;
+
   private PMatrix3D eyeMatrix;
+  private PMatrix3D objMatrix;
+
+  // Variables used in ray casting
+  private PVector[] ray;
+  private PVector hit = new PVector();
+  private PVector screen = new PVector();
+  private PVector objCenter = new PVector();
+  private PVector objToOrig = new PVector();
+  private PVector origInObjCoord = new PVector();
+  private PVector hitInObjCoord = new PVector();
+  private PVector dirInObjCoord = new PVector();
 
   @Override
   protected PGL createPGL(PGraphicsOpenGL pg) {
@@ -112,8 +124,7 @@ public void eye() {
     modelview.set(camera);
     modelview.apply(eyeMatrix);
 
-    // The 3x3 block of eyeMatrix is orthogonal, so taking the transpose
-    // inverts it...
+    // The 3x3 block of eyeMatrix is orthogonal, so taking the transpose inverts it...
     eyeMatrix.transpose();
     // ...and then invert the translation separately:
     eyeMatrix.m03 = -cameraX;
@@ -133,36 +144,173 @@ public void eye() {
 
 
   @Override
-  public boolean intersectsBox(float w, PVector origin, PVector dir) {
-    showMissingWarning("intersectsBox");
-    return false;
+  public PVector[] getRayFromScreen(float screenX, float screenY, PVector[] ray) {
+    if (ray == null || ray.length < 2) {
+      ray = new PVector[2];
+      ray[0] = new PVector();
+      ray[1] = new PVector();
+    }
+    getRayFromScreen(screenX, screenY, ray[0], ray[1]);
+    return ray;
   }
 
 
   @Override
-  public boolean intersectsBox(float w, float h, float d, PVector origin, PVector dir) {
-    showMissingWarning("intersectsBox");
-    return false;
+  public void getRayFromScreen(float screenX, float screenY, PVector origin, PVector direction) {
+    eyeMatrix = getEyeMatrix(eyeMatrix);
+
+    // Transforming screen coordinates to world coordinates
+    screen.x = screenX;
+    screen.y = screenY;
+    screen.z = 0;
+    eyeMatrix.mult(screen, origin);
+
+    // The direction of the ray is simply extracted from the third column of the eye matrix (the
+    // forward vector).
+    direction.set(eyeMatrix.m02, eyeMatrix.m12, eyeMatrix.m22);
   }
 
 
   @Override
-  public PVector intersectsPlane(PVector origin, PVector dir) {
-    showMissingWarning("intersectsPlane");
-    return null;
+  public boolean intersectsSphere(float r, float screenX, float screenY) {
+    ray = getRayFromScreen(screenX, screenY, ray);
+    return intersectsSphere(r, ray[0], ray[1]);
+  }
+
+
+  @Override
+  public boolean intersectsSphere(float r, PVector origin, PVector direction) {
+    // Get the center of the sphere in world coordinates
+    objCenter.x = modelview.m03;
+    objCenter.y = modelview.m13;
+    objCenter.z = modelview.m23;
+
+    PVector.sub(origin, objCenter, objToOrig);
+    float d = objToOrig.mag();
+
+    // The eye is inside the sphere
+    if (d <= r) return true;
+
+    // Check if sphere is in front of ray
+    if (PVector.dot(objToOrig, direction) > 0) return false;
+
+    // Check intersection of ray with sphere
+    float b = 2 * PVector.dot(direction, objToOrig);
+    float c = d * d - r * r;
+    float det = b * b - 4 * c;
+    return det >= 0;
+  }
+
+
+  @Override
+  public boolean intersectsBox(float size, float screenX, float screenY) {
+    ray = getRayFromScreen(screenX, screenY, ray);
+    return intersectsBox(size, size, size, ray[0], ray[1]);
+  }
+
+
+  @Override
+  public boolean intersectsBox(float w, float h, float d, float screenX, float screenY) {
+    ray = getRayFromScreen(screenX, screenY, ray);
+    return intersectsBox(w, h, d, ray[0], ray[1]);
+  }
+
+
+  @Override
+  public boolean intersectsBox(float size, PVector origin, PVector direction) {
+    return intersectsBox(size, size, size, origin, direction);
   }
 
 
   @Override
-  public boolean intersectsSphere(float r, PVector origin, PVector dir) {
-    showMissingWarning("intersectsSphere");
+  public boolean intersectsBox(float w, float h, float d, PVector origin, PVector direction) {
+    objMatrix = getObjectMatrix(objMatrix);
+    objMatrix.mult(origin, origInObjCoord);
+    PVector.add(origin, direction, hit);
+    objMatrix.mult(hit, hitInObjCoord);
+
+    PVector.sub(hitInObjCoord, origInObjCoord, dirInObjCoord);
+    return lineIntersectsAABB(origInObjCoord, dirInObjCoord, w, h, d);
+  }
+
+
+  // Line intersection with an axis-aligned bounding box (AABB), calculated using the algorithm
+  // from Amy William et al: http:// dl.acm.org/citation.cfm?id=1198748
+  protected boolean lineIntersectsAABB(PVector orig, PVector dir, float w, float h, float d) {
+    float minx = -w/2;
+    float miny = -h/2;
+    float minz = -d/2;
+
+    float maxx = +w/2;
+    float maxy = +h/2;
+    float maxz = +d/2;
+
+    float idx = 1/dir.x;
+    float idy = 1/dir.y;
+    float idz = 1/dir.z;
+
+    boolean sdx = idx < 0;
+    boolean sdy = idy < 0;
+    boolean sdz = idz < 0;
+
+    float bbx = sdx ? maxx : minx;
+    float txmin = (bbx - orig.x) * idx;
+    bbx = sdx ? minx : maxx;
+    float txmax = (bbx - orig.x) * idx;
+    float bby = sdy ? maxy : miny;
+    float tymin = (bby - orig.y) * idy;
+    bby = sdy ? miny : maxy;
+    float tymax = (bby - orig.y) * idy;
+
+    if ((txmin > tymax) || (tymin > txmax)) {
+      return false;
+    }
+    if (tymin > txmin) {
+      txmin = tymin;
+    }
+    if (tymax < txmax) {
+      txmax = tymax;
+    }
+
+    float bbz = sdz ? maxz : minz;
+    float tzmin = (bbz - orig.z) * idz;
+    bbz = sdz ? minz : maxz;
+    float tzmax = (bbz - orig.z) * idz;
+
+    if ((txmin > tzmax) || (tzmin > txmax)) {
+      return false;
+    }
+    if (tzmin > txmin) {
+      txmin = tzmin;
+    }
+    if (tzmax < txmax) {
+      txmax = tzmax;
+    }
+
+    if ((txmin < defCameraFar) && (txmax > 0)) {
+      // The intersection coordinates:
+      // x = orig.x + txmin * dir.x;
+      // y = orig.y + txmin * dir.y;
+      // z = orig.z + txmin * dir.z;
+      return true;
+    }
+
     return false;
   }
 
 
+
+
   @Override
-  public PVector[] getRayFromScreen(float screenX, float screenY) {
-    showMissingWarning("getRayFromScreen");
+  public PVector intersectsPlane(float screenX, float screenY) {
+    ray = getRayFromScreen(screenX, screenY, ray);
+    return intersectsPlane(ray[0], ray[1]);
+  }
+
+
+  @Override
+  public PVector intersectsPlane(PVector origin, PVector direction) {
+    showMissingWarning("intersectsPlane");
     return null;
   }