collide.C

Go to the documentation of this file.

#include "collide.H"

/********************************************************
Given a velocity vector and a position, it will test all
objects found with the sps octree for collisions and 
return and new velocity that doesn't run through objects
********************************************************/
CWvec 
Collide::_get_move(CWpt& source, CWvec& velocity)
   { 
   Wpt dest = source + velocity; //destination to travel to
   Wtransf xf;

   //adjust camera and destination bounding spheres to match given position
   xf = Wtransf::translation(source - _BSphere->get_bb().center());
   _BSphere->transform(xf);

   xf = Wtransf::translation(Wpt(source+velocity) - _DestSphere->get_bb().center());
   _DestSphere->transform(xf);
 
   //Using the camera and destination spheres create a 
   //bounding box containing all possible faces that can be hit
   _polyBox = _BSphere->get_bb() + _DestSphere->get_bb();

   //make sure the list of potential colliders is empty
   _hitFaces.clear(); 

   //for all objects in the scene build collision list
   for(int i = 0; i < _RootNodes.num(); i++)
      buildCollisionList(_RootNodes[i]);

    //if there are no potential collisions return velocity
    if (_hitFaces.empty())
      return velocity;
      

   // Determine the nearest collider from the list potentialColliders
   bool   first = true;
   double nearDist = -1.0;
   Bface* nearCollide = NULL;
   Wpt  nearIntersect;
   Wpt  nearFaceIntersect;
    Wpt polyIntersect;

   //for all potential colliders(faces)
   for(int i = 0; i < _hitFaces.num(); i++)
      {
      Wpt camIntersect;   //the point within the camera bounding sphere that
                     //*will* hit the face 
      Wpt faceIntersect;

      Wpt fOrigin = _hitFaces[i]->centroid(); //face origin(chosen as the centroid)
      Wvec fNorm = _hitFaces[i]->norm(); //face normal

      //get the distance from the current face to camera source
      double fDist = intersect(source, -fNorm, fOrigin, fNorm); 
   
      //radius vector of the bounding sphere in the direction of face's normal
                // XXX - compile error here: can't assign Wpt to Wvec.
                //       not sure what is supposed to be computed, so
                //       doing a quick fix: -- sapo
      Wvec dRad = (source - (fNorm * (_size/fNorm.length())))
                   - Wpt::Origin(); // quick fix
      
      double radius = _size; 

      //if the face is within the bounding sphere radius
      if(fabs(fDist) <= radius)
         {
         //calc the face intersection point
         Wvec distNorm = fNorm * (fDist/fNorm.length()); 
         faceIntersect = source + -distNorm;
         }
      else
         {
         camIntersect = source + (fNorm * (radius/fNorm.length()));
         double t = intersect(camIntersect, velocity, fOrigin, fNorm);

         // Calculate the face intersection point
         Wvec v = velocity *  (t/velocity.length());
         faceIntersect = camIntersect + v;
         }


      //set the polygon intersection point to the plane
      polyIntersect = faceIntersect;

      //if its not within the face, get the closest point
      if(!_hitFaces[i]->contains(faceIntersect))
         {
         Wvec bc; 
         bool inside = false;
         polyIntersect = _hitFaces[i]->nearest_pt(faceIntersect,bc,inside);//nearest point on poly's perimeter to plane intersect
         }

      
       Wvec invVelocity = -velocity; //inverted velocity

      //find the time in which the bounding sphere will interesect with
      //the face
      double t = intersectSphere(source,dRad,polyIntersect,radius);

      //if there is a reasonable intersection
      if(t>=0 && t <= velocity.length())
         {
         Wvec v = invVelocity * (t/invVelocity.length()); //with length set to t
         Wpt sPoint = polyIntersect + v; //point that we hit the sphere
         //set closests intersection info
          if (first || t < nearDist)
            {
            nearDist = t;
            nearCollide = _hitFaces[i];
            nearIntersect = sPoint;
            nearFaceIntersect = polyIntersect;
            first = false;
            }
         }
      }

   //if never found collision, return unchanged velocity
   if(first)
      return velocity;

    //create new velocity vector with length set to nearDist;
   Wvec v = velocity * (nearDist / velocity.length());

   if (v.length() < .01)
      return v;

    // Determine the sliding plane (for sliding against surfaces)
    Wpt newSource = source + v; 
    Wpt  slidePlaneO = nearFaceIntersect;
    Wvec  slidePlaneN = nearFaceIntersect - newSource;//newSource;

    double time = intersect(source+velocity, slidePlaneN, slidePlaneO, slidePlaneN);
    //Set length of slidePlaneNormal to time;
    //cout << "TIME: " << time << endl;
    Wvec destinationProjectionNormal = slidePlaneN  *  (time/slidePlaneN.length());
    Wpt  newDestinationPoint = dest + destinationProjectionNormal;

       // Generate the slide vector, which will become our new velocity vector
   // for the next iteration
    Wvec newVelocityVector = newDestinationPoint - newSource;//Wvec(Wpt::Origin() - nearFaceIntersect);

   return _get_move(source + v, newVelocityVector);
} 

bool 
Collide::_update_scene()
{
     CGELlist objects = VIEW::peek()->active();

      //create a octree and get the potential hit faces from it
      for (int i=0; i<objects.num(); i++) 
      {
        ARRAY<OctreeNode*> nodes;
      GEOMptr geom = GEOM::upcast(objects[i]);

      if (geom && BMESH::isa(geom->body())) 
         {
         Bvert_list list;
         Bface_list fs;
         ARRAY<Wvec> bcs;
         
         nodes += sps(BMESH::upcast(geom->body()), _height, _regularity, _min_dist, fs, bcs);
         _RootNodes.push(nodes[0]);
         _objs += 1;
         }
       } 


   return true;
}


double 
Collide::intersect(CWpt& pOrigin, CWvec& pNormal, CWpt& rOrigin, CWvec& rVector)
   {
   double d = -(Wvec(pOrigin) * pNormal);
   return -((pNormal * Wvec(rOrigin) + d) / (pNormal * rVector));
   }
   


double 
Collide::intersectSphere(CWpt& rO, CWvec& rV, CWpt& sO, double sR)
{
   Wvec Q = sO - rO;
   double c = Q.length();
   double v = Q * rV;
   double d = sR*sR - (c*c - v*v);

   // If there was no intersection, return -1

   if (d < 0.0) return -1.0;

   // Return the distance to the [first] intersecting point

   return v - sqrt(d);
} 

bool 
Collide::buildCollisionList(OctreeNode* node)
   {
   //if the bounding box doesn't intersect the node
   //then ignore it and its children
   if(node->get_leaf() != 1 && node->get_leaf() != 0)
      return false;

   //if the node doesn't overlap then no need to add children
   if(!node->overlaps(_polyBox))
      return false;


   //if the node has no children(its a leaf), add its triangles
if(node->get_leaf())
      _hitFaces = _hitFaces + node->intersects();
   else //else, check its children
      {
      OctreeNode** children =  node->get_children();
      for(int i = 0; i<8; i++)
         buildCollisionList(children[i]);
      }
   return true;
   }
/*
void Collide::set_size(double s)
{
   _size = s;

    _BSphere = new BMESH;
    _BSphere->Sphere(_BSphere->new_patch());
    _BSphere->transform(Wtransf::scaling(_size,_size,_size));


   _DestSphere = new BMESH;
    _DestSphere->Sphere(_DestSphere->new_patch());
    _DestSphere->transform(Wtransf::scaling(_size,_size,_size));
}
*/

////////////////////////////////
//Gravity
//
////////////////////////////



/////////////////////
//get_dir()
//given position, find the current gravity for that point
/////////////////////
CWvec 
Gravity::_get_dir(CWpt& p)
{
cout << "GEtting DIrection" << endl;
cout << _world << endl;

//If Gravity hasn't been set
if(_ground == NULL)
   return Wvec(0,0,0);

if(_currentGrav == WORLD)
   return _strength * _world_dir;

Wpt cent = _ground->bbox().center();
Wpt max  = _ground->bbox().max();

if(_currentGrav == GLOBE)
   return _strength * (cent-p).normalized();

if(_currentGrav == LANDSCAPE)
   return _strength * (Wvec(0,cent[1],0) - Wvec(0,max[1],0)).normalized();

return Wvec(0,0,0);

}


bool
Gravity::set_grav(GEOMptr g, mlib::CWvec& d, int t)
{
   cout << "GRAVITY BEING SET" << endl;
   _ground        = g;
   _world_dir     = d;
   _currentGrav   = t;
   return true;
}


void 
Gravity::set_globe(GEOMptr g)
{
   _ground     = g;
   _globe      = true;        
   _landscape  = false;
   _world      = false;

}
void 
Gravity::set_landscape(GEOMptr g)
{
   _ground     = g;
   _globe      = false;       
   _landscape  = true;
   _world      = false;
}
void Gravity::set_world(Wvec d)
{
   _world_dir  = d;
   _globe      = false;       
   _landscape  = false;
   _world      = true;
}



/* end of file collide.C */

---