}

 

  public static Octree buildTree(Vect3 center, List<? extends Object3D> objects){

    double maxQuadDist=0, qdist;

   

    System.out.print("Building octree... ");

   

    for(Object3D o : objects){

      Sphere s = o.getBoundingSphere();

      if(s!=null){

        Vect.subtract(center, s.getPosition(), dist);

        qdist = s.getRadius();

        if(Double.isInfinite(qdist)||Double.isNaN(qdist))

          throw new RuntimeException("Invalid BoundingSphere: "+s+" from "+o);

        if(maxQuadDist < qdist)

          maxQuadDist = qdist;

      }

    }

   

  public static Vect3 getCircumScribedCircleCenter(Vect3 a, Vect3 b, Vect3 c){

   

    Vect.subtract(b, a, mab);

    Vect.subtract(c, a, mac);

    Vect.crossProduct(mab, mac, normal);

    Vect.crossProduct(mab, normal, dab);

    Vect.crossProduct(mac, normal, dac);

    Vect.addMultiple(a, mab, 0.5, mab);

    Vect.addMultiple(a, mac, 0.5, mac);

    dab.normalize();

   

    if(Math.abs(dac.data[0])>1e-9&&Math.abs(dac.data[1])>1e-9&&Math.abs(dab.data[0]/dac.data[0] - dab.data[1]/dac.data[1])>1e-9){

      double x = ((mab.data[1]-mac.data[1])/dac.data[1] - (mab.data[0]-mac.data[0])/dac.data[0])/(dab.data[0]/dac.data[0] - dab.data[1]/dac.data[1]);

      Vect.addMultiple(mab, dab, x);

      for(double x = 1;x<camheight*3;x+=h)

        for(double z = -camheight;z<camheight;z+=h)

          addTree(x+Math.random()*dist-dist/2,-2,z+Math.random()*dist-dist/2);

       

        objects.add(c);

       

    }

     

      int leafColor = IntColors.A+(((int)(IntColors.G*(0.5 + 0.5*Math.random())))&IntColors.G);

     

      if(Math.random()<0.5){

      }else{

      }

    }

    private Octree tree;

   

    public MeshTest() throws IOException{

      double camheight= 50;

      //c = new Camera(new Vect3(-camheight, camheight*2, 0), new Vect3(-camheight+1, camheight*2-1, 0), new Vect3(0.707106781186547, 0.707106781186547, 0), 1, 1, 1);

      //c = new Camera(new Vect3(0, camheight*2, -camheight), new Vect3(0, camheight*2-1, -camheight+1), new Vect3(0, 0.707106781186547, 0.707106781186547), 1, 1, 1);

      //c = new Camera(new Vect3(0, camheight, -10), new Vect3(0, camheight-1, -10), new Vect3(0, 0, 1), 1, 1, 1);

        objects.add(c);

        TriangleMeshModel model = BinarySTLParser.parse(new File("models/elka.stl"));

       

        int nx = 2;

        int ny = 4;

        for(int i=-nx;i<=nx;i++)

          for(int j=-ny;j<=ny;j++)

       

        //objects.add(new Plane(new Vect3(0,0,0),new Vect3(0,1,0),0xFFFFFFFF));

    }

  private Camera cam;

 

  public KugelTest(){

    objects = new ArrayList<Object3D>();

  }

    /**

     * TODO: 3 vect3 allocated here...

     */

    public static double interpolateTriangleEdge1(Vect3 v1, Vect3 v2, Vect3 v3, Vect3 point){

      Vect.subtract(v3, v2, v23n);

     

      Vect.subtract(v1, v2, v21);

     

      Vect.project(v21, v23n, v1o);

      Vect.subtract(v1o, v21, v1o);

     

     

      Vect.scale(v1hn, 1/h1, v1hn); //normieren

     

      Vect.subtract(point, v1, v1p);

     

      Vect.project(v1p, v1hn, p1);

     

    }

      return 1-(p1.length()/h1);

    }

   

    public static Vect3 avg(Vect3 ... vects){

     

      for(Vect3 v : vects)

        Vect.add(ret, v, ret);

     

      Vect.scale(ret, 1/(float)vects.length, ret);

  private TriangleMeshModel model;

  private Map<Thread, CollisionData> lastCollision = new HashMap<Thread, CollisionData>();

 

  public ModelInstance(Vect3 position, TriangleMeshModel model) {

    this.model = model;

  }

  @Override

  public double getHitPointDistance(Ray r) {

    double dist;

    Ray subRay;

    Vect.add(position, model.getBoundingSphere().getPosition(), tmp);

   

    if(RaySphere.isRayOriginatingInSphere(r.getOrigin(), r.getDirection(), tmp, model.getBoundingSphere().getRadius())){

      Vect.subtract(r.getOrigin(), position, tmp);

      subRay = new Ray(tmp, r.getDirection());

     

      dist = 0;

    }else{

      dist=RaySphere.getHitPointRaySphereDistance(r.getOrigin(), r.getDirection(), tmp, model.getBoundingSphere().getRadius());

     

      if(Double.isInfinite(dist))

        return dist;

     

      Vect.addMultiple(r.getOrigin(), r.getDirection(), dist, tmp);

      Vect.subtract(tmp, position, tmp);

      subRay = new Ray(tmp, r.getDirection());

    }

   

    CollisionData d = new CollisionData();

    lastCollision.put(Thread.currentThread(), d);

    d.d = RayPath.getFirstCollision(model.getTree(), subRay);

    if(!Double.isInfinite(d.d.d)){

      Vect.addMultiple(subRay.getOrigin(), subRay.getDirection(), d.d.d, hitPointLocal);

      d.hitPointLocal = hitPointLocal;

      Vect.add(hitPointLocal, position, hitPointGlobal);

      d.hitPointGlobal = hitPointGlobal;

      return d.d.d + dist;

    }else{

      return d.d.d;