gistfile1.java

public abstract class OctNode implements Collidable, Animated, GLRenderable {

  protected final OctSpace space;

  public OctNode(OctSpace space) {
    this.space = space;
  }

  public OctSpace getSpace() {
    return space;
  }
}

public class OctLeaf<T extends Collidable & GLRenderable> extends OctNode {

  private final T target;

  public OctLeaf(OctSpace space, T target) {
    super(space);
    this.target = target;
  }

  @Override
  public CollisionDetails collide(Line line, double accuracy) {
    return target.collide(line, accuracy);
  }

  @Override
  public void tickAnim() {
    if(target instanceof Animated)
      ((Animated)target).tickAnim();
  }

  @Override
  public void restartAnim() {
    if(target instanceof Animated)
      ((Animated)target).restartAnim();
  }

  @Override
  public void render(GL2 gl) {
    target.render(gl);
  }

  @Override
  public Vector<CollisionDetails> collide(CollisionFrustrum box, double accuracy) {
    return target.collide(box, accuracy);
  }
}

public class OctTree extends OctNode {

  private OctNode[] elements;

  public OctTree(OctSpace space, OctNode[] elements) {
    super(space);
    this.elements = elements;
  }

  @Override
  public CollisionDetails collide(Line line, double accuracy) {
    CollisionDetails nearestCollision = new NullCollision();

    for (OctNode element : elements) {
      CollisionDetails collision = element.collide(line, accuracy);

      if (collision.distance < nearestCollision.distance)
        nearestCollision = collision;
    }

    return nearestCollision;
  }

  @Override
  public Vector<CollisionDetails> collide(CollisionFrustrum frustrum, double accuracy) {
    Vector<CollisionDetails> collisions = new Vector<CollisionDetails>();
    
    if(frustrum.collide(space, accuracy))
    {
      for (OctNode element : elements)
      {
        collisions.addAll(element.collide(frustrum, accuracy));
      }
    }
    
    return collisions;
  }
  
  @Override
  public void tickAnim() {
    for (OctNode element : elements)
      element.tickAnim();
  }

  @Override
  public void restartAnim() {
    for (OctNode element : elements)
      element.restartAnim();
  }

  @Override
  public void render(GL2 gl) {
    for (OctNode element : elements)
      element.render(gl);
  }

}

public class NullLeaf extends OctNode {

  public NullLeaf(OctSpace space) {
    super(space);
  }

  @Override
  public CollisionDetails collide(Line line, double accuracy) {
    return new NullCollision();
  }

  @Override
  public void tickAnim() {}

  @Override
  public void restartAnim() {}

  @Override
  public void render(GL2 gl) {}

  @Override
  public Vector<CollisionDetails> collide(CollisionFrustrum box, double accuracy) {
    return new Vector<CollisionDetails>();
  }

}

public class OctSpace {
  private final double size;
  private final Vertex center;
  public final Vertex[] points = new Vertex[8];

  public OctSpace(Vertex center, double size) {
    
    this.size = size;
    this.center = center;
    
    int i = 0;
    for (int x = -1; x < 2; x += 2)
      for (int y = -1; y < 2; y += 2)
        for (int z = -1; z < 2; z += 2)
          points[i++] = new Vertex(center.x + size*x, center.y + size*y, center.z + size*z);
  }

  public Vertex getCenter() {
    return (Vertex) center.clone();
  }

  public double getSize() {
    return size;
  }

  public boolean isContained(Vertex point) {
    boolean xInside = isContained(point.x, center.x);
    boolean yInside = isContained(point.y, center.y);
    boolean zInside = isContained(point.z, center.z);

    return xInside && yInside && zInside;
  }

  private boolean isContained(double x, double center) {
    return inbetween(x, center + size, center - size);
  }

  private boolean inbetween(double x, double max, double min) {
    boolean bigEnough = x >= min;
    boolean smallEnough = x <= max;
    return (bigEnough && smallEnough);
  }
}

public class NullCollision extends CollisionDetails {

  private static final int MAX_DISTANCE = 9999;

  public NullCollision() {
    super(null, MAX_DISTANCE);
  }

}

public class CollisionDetails {
  public final Collidable source;
  public final double distance;

  public CollisionDetails(Collidable contained, double accuracy) {
    this.source = contained;
    this.distance = accuracy;
  }
}