[simspark-cvs] simspark/spark/oxygen/physicsserver space.cpp, 1.1.2.2, 1.1.2.2.2.1

[Oliver O. <fr...@us...>]

Update of /cvsroot/simspark/simspark/spark/oxygen/physicsserver
In directory sc8-pr-cvs8.sourceforge.net:/tmp/cvs-serv29704

Modified Files:
      Tag: projectx
	space.cpp 
Log Message:
merge from HEAD


Index: space.cpp
===================================================================
RCS file: /cvsroot/simspark/simspark/spark/oxygen/physicsserver/space.cpp,v
retrieving revision 1.1.2.2
retrieving revision 1.1.2.2.2.1
diff -C2 -d -r1.1.2.2 -r1.1.2.2.2.1
*** space.cpp	15 Feb 2007 21:00:19 -0000	1.1.2.2
--- space.cpp	17 Jun 2007 08:09:25 -0000	1.1.2.2.2.1
***************
*** 29,33 ****
  using namespace oxygen;
  
! static void collisionNearCallback (void *data, dGeomID obj1, dGeomID obj2)
  {
      Space *space = (Space*)data;
--- 29,33 ----
  using namespace oxygen;
  
! void Space::collisionNearCallback (void *data, dGeomID obj1, dGeomID obj2)
  {
      Space *space = (Space*)data;
***************
*** 64,70 ****
  }
  
  void Space::HandleCollide(dGeomID obj1, dGeomID obj2)
  {
!     // reject collisions between bodies that are connected with joints
      const dBodyID b1 = dGeomGetBody(obj1);
      const dBodyID b2 = dGeomGetBody(obj2);
--- 64,97 ----
  }
  
+ void Space::HandleSpaceCollide(dGeomID obj1, dGeomID obj2)
+ {
+     // collide all geoms internal to the space(s)
+     dSpaceCollide2 (obj1,obj2,this,&collisionNearCallback);
+ 
+     if (dGeomIsSpace (obj1))
+         {
+             dSpaceCollide ((dSpaceID)(obj1),this,&collisionNearCallback);
+         }
+ 
+     if (dGeomIsSpace (obj2))
+         {
+             dSpaceCollide ((dSpaceID)(obj2),this,&collisionNearCallback);
+         }
+ }
+ 
  void Space::HandleCollide(dGeomID obj1, dGeomID obj2)
  {
!     if (
!         (dGeomIsSpace (obj1)) ||
!         (dGeomIsSpace (obj2))
!         )
!         {
!             // colliding a space with something
!             HandleSpaceCollide(obj1, obj2);
!             return;
!         }
! 
!     // colliding two non-space geoms; reject collisions
!     // between bodies that are connected with joints
      const dBodyID b1 = dGeomGetBody(obj1);
      const dBodyID b2 = dGeomGetBody(obj2);
***************
*** 112,129 ****
  }
  
  bool Space::ConstructInternal()
  {
!   // create the ode space, 0 indicates that this space should
!   // not be inserted into another space, i.e. we always create a
!   // toplevel space object
!   mODESpace = dHashSpaceCreate(0);
  
!   // create a joint group for the contacts
!   mODEContactGroup = dJointGroupCreate(0);
  
!   return (
!           (mODESpace != 0) &&
!           (mODEContactGroup != 0)
!           );
  }
  
--- 139,190 ----
  }
  
+ void Space::OnLink()
+ {
+     ODEObject::OnLink();
+ 
+     dSpaceID space = FindSpaceID();
+     if (
+         (space) &&
+         (space != mODESpace) &&
+         (! dSpaceQuery(space, (dGeomID)mODESpace))
+         )
+         {
+             dSpaceAdd(space, (dGeomID)mODESpace);
+         }
+ }
+ 
+ dSpaceID Space::GetParentSpaceID()
+ {
+     if (mODESpace == 0)
+         {
+             return 0;
+         }
+ 
+     return dGeomGetSpace((dGeomID)mODESpace);
+ }
+ 
+ bool Space::IsGlobalSpace()
+ {
+     return
+         (
+         (mODESpace != 0) &&
+         (GetParentSpaceID() == 0)
+         );
+ }
+ 
  bool Space::ConstructInternal()
  {
!     // create the ode space, 0 indicates that this space should
!     // not be inserted into another space, i.e. we always create a
!     // toplevel space object
!     mODESpace = dHashSpaceCreate(0);
  
!     // create a joint group for the contacts
!     mODEContactGroup = dJointGroupCreate(0);
  
!     return (
!             (mODESpace != 0) &&
!             (mODEContactGroup != 0)
!             );
  }
  
***************
*** 134,188 ****
  }
  
! void Space::DestroySpaceObjects()
  {
!   shared_ptr<Scene> scene = GetScene();
!   if (scene.get() == 0)
!     {
!       return;
!     }
  
!   TLeafList objects;
  
!   const bool recursive = true;
!   scene->ListChildrenSupportingClass<ODEObject>(objects, recursive);
  
!   for (
!        TLeafList::iterator iter = objects.begin();
!        iter != objects.end();
!        ++iter
!        )
!     {
!       shared_ptr<ODEObject> object = shared_static_cast<ODEObject>(*iter);
!       if (object->GetSpaceID() != mODESpace)
          {
!           continue;
!         }
  
!       object->DestroyODEObject();
!     }
  }
  
! void Space::DestroyODEObject()
  {
!   static bool recurseLock = false;
! 
!   if (
!       (recurseLock) ||
!       (! mODESpace)
!       )
!     {
!         return;
!     }
! 
!   recurseLock = true;
! 
!   // make sure that all objects registered to this space are destroyed
!   // before this space. Any other order provokes a segfault in ODE.
!   DestroySpaceObjects();
  
!   // release the ODE space
!   dSpaceDestroy(mODESpace);
!   mODESpace = 0;
  
!   recurseLock = false;
  }
--- 195,256 ----
  }
  
! void 
! Space::DestroySpaceObjects()
  {
!     shared_ptr<Scene> scene = GetScene();
!     if (scene.get() == 0)
!         {
!             return;
!         }
  
!     TLeafList objects;
!     const bool recursive = true;
!     scene->ListChildrenSupportingClass<ODEObject>(objects, recursive);
  
!     bool globalSpace = IsGlobalSpace();
!     shared_ptr<Space> self = shared_static_cast<Space>(GetSelf().lock());
  
!     for (
!          TLeafList::iterator iter = objects.begin();
!          iter != objects.end();
!          ++iter
!          )
          {
!             shared_ptr<ODEObject> object = shared_static_cast<ODEObject>(*iter);
!             if (object == self)
!             {
!                 continue;
!             }
  
!             // destroy objects registered to this space; the top level
!             // space object also destroy any other ODE object
!             const dSpaceID parentSpace = object->GetParentSpaceID();
!             if (
!                 (
!                  (globalSpace) &&
!                  (parentSpace == 0)
!                  ) ||
!                 (parentSpace == mODESpace)
!                 )
!                 {
!                     object->DestroyODEObject();
!                 }
!         }
  }
  
! void 
! Space::DestroyODEObject()
  {
!     if (! mODESpace)
!         {
!             return;
!         }
  
!     // make sure that all objects registered to this space are destroyed
!     // before this space. Any other order provokes a segfault in ODE.
!     DestroySpaceObjects();
  
!     // release the ODE space
!     dSpaceDestroy(mODESpace);
!     mODESpace = 0;
  }