Menu
▾
▴
[simspark-svn] SF.net SVN: simspark:[143] branches/multiphys/spark/lib/oxygen/ physicsserver
|
From: <a-...@us...> - 2010-01-14 09:15:21
|
Revision: 143
http://simspark.svn.sourceforge.net/simspark/?rev=143&view=rev
Author: a-held
Date: 2010-01-14 09:15:14 +0000 (Thu, 14 Jan 2010)
Log Message:
-----------
Completed bridge pattern for Space class
Completed Abstract Physics Layer! :-)
Modified Paths:
--------------
branches/multiphys/spark/lib/oxygen/physicsserver/int/spaceint.h
branches/multiphys/spark/lib/oxygen/physicsserver/ode/odespace.cpp
branches/multiphys/spark/lib/oxygen/physicsserver/ode/odespace.h
branches/multiphys/spark/lib/oxygen/physicsserver/space.cpp
branches/multiphys/spark/lib/oxygen/physicsserver/space.h
branches/multiphys/spark/lib/oxygen/physicsserver/staticphysicsmethods_ode.cpp
Modified: branches/multiphys/spark/lib/oxygen/physicsserver/int/spaceint.h
===================================================================
--- branches/multiphys/spark/lib/oxygen/physicsserver/int/spaceint.h 2010-01-13 13:21:31 UTC (rev 142)
+++ branches/multiphys/spark/lib/oxygen/physicsserver/int/spaceint.h 2010-01-14 09:15:14 UTC (rev 143)
@@ -25,39 +25,33 @@
#include <set>
#include <oxygen/oxygen_defines.h>
+#include <oxygen/physicsserver/genericphysicsobjects.h>
namespace oxygen
{
class Transform;
class RigidBody;
class Collider;
-class Scene;
+class Space;
class OXYGEN_API SpaceInt
{
public:
- typedef std::set<dSpaceID> TSpaceIdSet;
-
- //virtual void collisionNearCallback (void *data, dGeomID obj1, dGeomID obj2) = 0;
- virtual long GetSpaceID() const = 0;
- virtual dJointGroupID GetODEJointGroup() const = 0;
- virtual void Collide() = 0;
- virtual void DestroyPhysicsObject() = 0;
- virtual long GetParentSpaceID() = 0;
- virtual bool IsGlobalSpace() = 0;
- virtual void DisableInnerCollision(bool disable) = 0;
- virtual bool GetDisableInnerCollision() const = 0;
- virtual void OnUnlink() = 0;
- virtual void OnLink() = 0;
- virtual void Collide(dSpaceID space) = 0;
- virtual void HandleCollide(dGeomID obj1, dGeomID obj2) = 0;
- virtual void HandleSpaceCollide(dGeomID obj1, dGeomID obj2) = 0;
- virtual bool ConstructInternal() = 0;
- virtual void PostPhysicsUpdateInternal() = 0;
- virtual void DestroySpaceObjects() = 0;
-
- boost::shared_ptr<Scene> scene;
+ virtual long CreateSpace(long spaceID) = 0;
+ virtual void DestroySpace(long contactGroup, long spaceID) = 0;
+ virtual long GetParentSpaceID(long spaceID) = 0;
+ virtual void Collide(long space, Space* callee) = 0;
+ virtual void Collide2(long obj1, long obj2, Space* callee) = 0;
+ virtual long ConstructInternal() = 0;
+ virtual void PostPhysicsUpdateInternal(long contactGroup) = 0;
+ virtual bool ObjectIsSpace(long objectID) = 0;
+ virtual long FetchBody(long geomID) = 0;
+ virtual long FetchSpace(long geomID) = 0;
+ virtual bool AreConnectedWithJoint(long bodyID1, long bodyID2) = 0;
+ virtual void CollideInternal(boost::shared_ptr<Collider> collider,
+ boost::shared_ptr<Collider> collidee,
+ long geomID1, long geomID2) = 0;
};
} //namespace oxygen
Modified: branches/multiphys/spark/lib/oxygen/physicsserver/ode/odespace.cpp
===================================================================
--- branches/multiphys/spark/lib/oxygen/physicsserver/ode/odespace.cpp 2010-01-13 13:21:31 UTC (rev 142)
+++ branches/multiphys/spark/lib/oxygen/physicsserver/ode/odespace.cpp 2010-01-14 09:15:14 UTC (rev 143)
@@ -24,119 +24,107 @@
#include <oxygen/physicsserver/collider.h>
#include <oxygen/physicsserver/space.h>
#include <oxygen/sceneserver/scene.h>
-#include <zeitgeist/logserver/logserver.h>
using namespace boost;
using namespace oxygen;
-/** set of spaces with disabled inner collision */
-ODESpace::TSpaceIdSet ODESpace::gDisabledInnerCollisionSet;
-
-//void ODESpace::collisionNearCallback (void *data, dGeomID obj1, dGeomID obj2)
-//{
- // Space *space = (Space*)data;
- // space->HandleCollide(obj1, obj2);
-//}
-
-ODESpace::ODESpace() : ODEPhysicsObject(), mODESpace(0), mODEContactGroup(0)
+void ODESpace::collisionNearCallback(void* data, dGeomID obj1, dGeomID obj2)
{
+ Space* space = (Space*) data;
+ space->HandleCollide((long) obj1, (long) obj2);
}
-long ODESpace::GetSpaceID() const
+ODESpace::ODESpace() : ODEPhysicsObject()
{
- return (long) mODESpace;
}
-dJointGroupID ODESpace::GetODEJointGroup() const
+void ODESpace::Collide(long space, Space* callee)
{
- return mODEContactGroup;
+ dSpaceID ODESpace = (dSpaceID) space;
+ dSpaceCollide(ODESpace, callee, collisionNearCallback);
}
-void ODESpace::Collide()
+void ODESpace::Collide2(long obj1, long obj2, Space* callee)
{
- // bind collision callback function to this object
- Collide(mODESpace);
+ dGeomID ODEObj1 = (dGeomID) obj1;
+ dGeomID ODEObj2 = (dGeomID) obj2;
+ dSpaceCollide2(ODEObj1, ODEObj2, callee, &collisionNearCallback);
}
-void ODESpace::Collide(dSpaceID space)
+long ODESpace::GetParentSpaceID(long spaceID)
{
- if (gDisabledInnerCollisionSet.find(space) == gDisabledInnerCollisionSet.end())
- {
- //dSpaceCollide(space, this, Space::collisionNearCallback);
- }
+ dGeomID ODESpace = (dGeomID) spaceID;
+ dSpaceID parentSpace = dGeomGetSpace(ODESpace);
+ return (long) parentSpace;
}
-void ODESpace::HandleSpaceCollide(dGeomID obj1, dGeomID obj2)
+long ODESpace::ConstructInternal()
{
- // collide all geoms internal to the space(s)
- //dSpaceCollide2 (obj1,obj2,this,&Space::collisionNearCallback);
+ // create a joint group for the contacts
+ dJointGroupID ODEContactGroup = dJointGroupCreate(0);
- if (dGeomIsSpace (obj1))
- {
- Collide((dSpaceID)obj1);
- }
+ return (long) ODEContactGroup;
+}
- if (dGeomIsSpace (obj2))
- {
- Collide((dSpaceID)obj2);
- }
+void ODESpace::PostPhysicsUpdateInternal(long contactGroup)
+{
+ dJointGroupID ODEContactGroup = (dJointGroupID) contactGroup;
+ // remove all contact joints
+ dJointGroupEmpty(ODEContactGroup);
}
-void ODESpace::HandleCollide(dGeomID obj1, dGeomID obj2)
+long ODESpace::CreateSpace(long spaceID){
+ dSpaceID ODESpace = (dSpaceID) spaceID;
+ dSpaceID CreatedSpace = dHashSpaceCreate(ODESpace);
+ return (long) CreatedSpace;
+}
+
+void ODESpace::DestroySpace(long contactGroup, long spaceID)
{
- if (
- (dGeomIsSpace (obj1)) ||
- (dGeomIsSpace (obj2))
- )
+ dJointGroupID ODEContactGroup = (dJointGroupID) contactGroup;
+ dSpaceID ODESpace = (dSpaceID) spaceID;
+
+ if (ODEContactGroup)
{
- // colliding a space with something
- HandleSpaceCollide(obj1, obj2);
- return;
+ dJointGroupDestroy(ODEContactGroup);
}
- // colliding two non-space geoms; reject collisions
- // between bodies that are connected with joints
- const dBodyID b1 = dGeomGetBody(obj1);
- const dBodyID b2 = dGeomGetBody(obj2);
+ // release the ODE space
+ dSpaceDestroy(ODESpace);
+}
- if (
- (b1) && (b2) &&
- (dAreConnectedExcluding(b1,b2,dJointTypeContact))
- )
- {
- return;
- }
+bool ODESpace::ObjectIsSpace(long objectID){
+ dGeomID ODEGeom = (dGeomID) objectID;
+ return dGeomIsSpace(ODEGeom);
+}
- // if obj1 and obj2 are in a space that disabled inner collision,
- // reject the collision
- const dSpaceID s1 = dGeomGetSpace(obj1);
- const dSpaceID s2 = dGeomGetSpace(obj2);
+long ODESpace::FetchBody(long geomID){
+ dGeomID ODEGeom = (dGeomID) geomID;
+ dBodyID ODEBody = dGeomGetBody(ODEGeom);
+ return (long) ODEBody;
+}
- // get shared pointers to the two corresponding Collider nodes first
- shared_ptr<Collider> collider = Collider::GetCollider((long) obj1);
- shared_ptr<Collider> collidee = Collider::GetCollider((long) obj2);
+long ODESpace::FetchSpace(long geomID){
+ dGeomID ODEGeom = (dGeomID) geomID;
+ dSpaceID ODESpace = dGeomGetSpace(ODEGeom);
+ return (long) ODESpace;
+}
- if (
- (collider.get() == 0) ||
- (collidee.get() == 0)
- )
- {
- return;
- }
+bool ODESpace::AreConnectedWithJoint(long bodyID1, long bodyID2){
+ if ((!bodyID1) || (!bodyID2))
+ return false;
- if (s1 == s2)
- {
- const oxygen::Collider::TColliderNameSet & collider_set = collider->GetNotCollideWithSet();
- const oxygen::Collider::TColliderNameSet & collidee_set = collidee->GetNotCollideWithSet();
- if (
- (collider_set.find(collidee->GetName()) != collider_set.end()) ||
- (collidee_set.find(collider->GetName()) != collidee_set.end())
- )
- {
- return;
- }
- }
+ dBodyID ODEBody1 = (dBodyID) bodyID1;
+ dBodyID ODEBody2 = (dBodyID) bodyID2;
+ return dAreConnectedExcluding(ODEBody1, ODEBody2, dJointTypeContact);
+}
+void ODESpace::CollideInternal(boost::shared_ptr<Collider> collider,
+ boost::shared_ptr<Collider> collidee,
+ long geomID1, long geomID2)
+{
+ dGeomID geom1 = (dGeomID) geomID1;
+ dGeomID geom2 = (dGeomID) geomID2;
// dSpaceCollide(), is guaranteed to pass all potentially
// intersecting geom pairs to the callback function, but depending
// on the internal algorithms used by the space it may also make
@@ -146,8 +134,8 @@
static const int nContacts = 4;
static dContact contacts[nContacts];
- int n = dCollide (obj1, obj2, nContacts,
- &contacts[0].geom, sizeof(dContact));
+ int n = dCollide (geom1, geom2, nContacts,
+ &contacts[0].geom, sizeof(dContact));
if (n == 0)
{
@@ -158,153 +146,7 @@
for (int i=0;i<n;++i)
{
// notify the collider nodes
- //collider->OnCollision(collidee,contacts[i],Collider::CT_DIRECT);
- //collidee->OnCollision(collider,contacts[i],Collider::CT_SYMMETRIC);
+ collider->OnCollision(collidee,(GenericContact&) contacts[i],Collider::CT_DIRECT);
+ collidee->OnCollision(collider,(GenericContact&) contacts[i],Collider::CT_SYMMETRIC);
}
}
-
-void ODESpace::OnUnlink()
-{
- DisableInnerCollision(false);
-}
-
-void ODESpace::OnLink()
-{
- /*shared_ptr<Space> space = GetSpace();
- dSpaceID spaceID = 0;
-
- if (space.get() != 0)
- {
- spaceID = (dSpaceID) space->GetSpaceID();
- }
-
- mODESpace = dHashSpaceCreate(spaceID);*/
-}
-
-long ODESpace::GetParentSpaceID()
-{
- if (mODESpace == 0)
- {
- return 0;
- }
-
- return (long) dGeomGetSpace((dGeomID)mODESpace);
-}
-
-bool ODESpace::IsGlobalSpace()
-{
- return
- (
- (mODESpace != 0) &&
- (GetParentSpaceID() == 0)
- );
-}
-
-bool ODESpace::ConstructInternal()
-{
- // create a joint group for the contacts
- mODEContactGroup = dJointGroupCreate(0);
-
- return (mODEContactGroup != 0);
-}
-
-void ODESpace::PostPhysicsUpdateInternal()
-{
- // remove all contact joints
- dJointGroupEmpty (mODEContactGroup);
-}
-
-void ODESpace::DestroySpaceObjects(){}
-/*{
- if (scene.get() == 0)
- {
- return;
- }
-
- TLeafList objects;
- const bool recursive = true;
- scene->ListChildrenSupportingClass<PhysicsObject>(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<PhysicsObject> object = shared_static_cast<PhysicsObject>(*iter);
- if (object == self)
- {
- continue;
- }
-
- // destroy objects registered to this space; the top level
- // space object also destroy any other ODE object
- const long parentSpace = object->GetParentSpaceID();
- if (
- (
- (globalSpace) &&
- (parentSpace == 0)
- ) ||
- (parentSpace == (long) mODESpace)
- )
- {
- object->DestroyPhysicsObject();
- }
- }
-}*/
-
-void ODESpace::DestroyPhysicsObject()
-{
- 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();
-
- if (mODEContactGroup)
- {
- dJointGroupDestroy(mODEContactGroup);
- mODEContactGroup = 0;
- }
-
- // release the ODE space
- dSpaceDestroy(mODESpace);
- mODESpace = 0;
-}
-
-void ODESpace::DisableInnerCollision(bool disable)
-{
- if (mODESpace == 0)
- {
- //assert(false);
- return;
- }
-
- if (disable)
- {
- gDisabledInnerCollisionSet.insert(mODESpace);
- return;
- }
-
- TSpaceIdSet::iterator iter = gDisabledInnerCollisionSet.find(mODESpace);
- if (iter == gDisabledInnerCollisionSet.end())
- {
- return;
- }
-
- gDisabledInnerCollisionSet.erase(iter);
-}
-
-bool ODESpace::GetDisableInnerCollision() const
-{
- TSpaceIdSet::const_iterator iter
- = gDisabledInnerCollisionSet.find(mODESpace);
-
- return (iter != gDisabledInnerCollisionSet.end());
-}
Modified: branches/multiphys/spark/lib/oxygen/physicsserver/ode/odespace.h
===================================================================
--- branches/multiphys/spark/lib/oxygen/physicsserver/ode/odespace.h 2010-01-13 13:21:31 UTC (rev 142)
+++ branches/multiphys/spark/lib/oxygen/physicsserver/ode/odespace.h 2010-01-14 09:15:14 UTC (rev 143)
@@ -28,43 +28,31 @@
namespace oxygen
{
+class Space;
class OXYGEN_API ODESpace : public SpaceInt, public ODEPhysicsObject
{
public:
- typedef std::set<dSpaceID> TSpaceIdSet;
-
-public:
ODESpace();
-
- long GetSpaceID() const;
- dJointGroupID GetODEJointGroup() const;
- void Collide();
- virtual void DestroyPhysicsObject();
- virtual long GetParentSpaceID();
- bool IsGlobalSpace();
- void DisableInnerCollision(bool disable);
- bool GetDisableInnerCollision() const;
- dSpaceID mODESpace;
-
-protected:
- //void collisionNearCallback (void *data, dGeomID obj1, dGeomID obj2);
- virtual void OnUnlink();
- virtual void OnLink();
- void Collide(dSpaceID space);
- void HandleCollide(dGeomID obj1, dGeomID obj2);
- void HandleSpaceCollide(dGeomID obj1, dGeomID obj2);
- virtual bool ConstructInternal();
- virtual void PostPhysicsUpdateInternal();
- void DestroySpaceObjects();
-
+ long CreateSpace(long spaceID);
+ void DestroySpace(long contactGroup, long spaceID);
+ long GetParentSpaceID(long spaceID);
+ long ConstructInternal();
+ void PostPhysicsUpdateInternal(long contactGroup);
+ void Collide(long spaceID, Space* callee);
+ void Collide2(long obj1, long obj2, Space* callee);
+ bool ObjectIsSpace(long objectID);
+ long FetchBody(long geomID);
+ long FetchSpace(long geomID);
+ bool AreConnectedWithJoint(long bodyID1, long bodyID2);
+ void CollideInternal(boost::shared_ptr<Collider> collider,
+ boost::shared_ptr<Collider> collidee,
+ long geomID1, long geomID2);
+
private:
- dJointGroupID mODEContactGroup;
-
-private:
- static TSpaceIdSet gDisabledInnerCollisionSet;
+ static void collisionNearCallback(void* data, dGeomID obj1, dGeomID obj2);
};
}
Modified: branches/multiphys/spark/lib/oxygen/physicsserver/space.cpp
===================================================================
--- branches/multiphys/spark/lib/oxygen/physicsserver/space.cpp 2010-01-13 13:21:31 UTC (rev 142)
+++ branches/multiphys/spark/lib/oxygen/physicsserver/space.cpp 2010-01-14 09:15:14 UTC (rev 143)
@@ -24,7 +24,6 @@
#include <oxygen/physicsserver/collider.h>
#include <oxygen/physicsserver/world.h>
#include <oxygen/sceneserver/scene.h>
-#include <zeitgeist/logserver/logserver.h>
using namespace boost;
using namespace oxygen;
@@ -32,14 +31,8 @@
/** set of spaces with disabled inner collision */
Space::TSpaceIdSet Space::gDisabledInnerCollisionSet;
-void Space::collisionNearCallback (void *data, dGeomID obj1, dGeomID obj2)
+Space::Space() : PhysicsObject(), mSpaceID(0)
{
- Space *space = (Space*)data;
- space->HandleCollide((long) obj1, (long) obj2);
-}
-
-Space::Space() : PhysicsObject(), mODESpace(0)
-{
mSpaceImp = shared_ptr<ODESpace>(new ODESpace());
}
@@ -49,80 +42,70 @@
long Space::GetSpaceID() const
{
- return mSpaceImp->GetSpaceID();
+ return mSpaceID;
}
long Space::GetODEJointGroup() const
{
- return (long) mSpaceImp->GetODEJointGroup();
+ return mContactGroupID;
}
void Space::Collide()
{
// bind collision callback function to this object
- Collide(mODESpace);
+ Collide(mSpaceID);
}
-void Space::Collide(dSpaceID space)
+void Space::Collide(long space)
{
if (gDisabledInnerCollisionSet.find(space) == gDisabledInnerCollisionSet.end())
{
- dSpaceCollide(space, this, collisionNearCallback);
+ mSpaceImp->Collide(space, this);
}
}
-void Space::HandleSpaceCollide(dGeomID obj1, dGeomID obj2)
-{
- // collide all geoms internal to the space(s)
- dSpaceCollide2 (obj1,obj2,this,&collisionNearCallback);
-
- //mSpaceImp->HandleSpaceCollide(obj1, obj2);
+void Space::HandleSpaceCollide(long obj1, long obj2)
+{
+ // collide all geoms internal to the space(s)
+ mSpaceImp->Collide2(obj1, obj2, this);
- if (dGeomIsSpace (obj1))
+ if (mSpaceImp->ObjectIsSpace(obj1))
{
- Collide((dSpaceID)obj1);
+ Collide(obj1);
}
- if (dGeomIsSpace (obj2))
+ if (mSpaceImp->ObjectIsSpace(obj2))
{
- Collide((dSpaceID)obj2);
+ Collide(obj2);
}
}
void Space::HandleCollide(long obj1, long obj2)
-{
- //mSpaceImp->HandleCollide(obj1, obj2);
-
- dGeomID geom1 = (dGeomID) obj1;
- dGeomID geom2 = (dGeomID) obj2;
-
+{
if (
- (dGeomIsSpace (geom1)) ||
- (dGeomIsSpace (geom2))
+ (mSpaceImp->ObjectIsSpace(obj1)) ||
+ (mSpaceImp->ObjectIsSpace(obj2))
)
{
// colliding a space with something
- HandleSpaceCollide(geom1, geom2);
+ HandleSpaceCollide(obj1, obj2);
return;
}
// colliding two non-space geoms; reject collisions
// between bodies that are connected with joints
- const dBodyID b1 = dGeomGetBody(geom1);
- const dBodyID b2 = dGeomGetBody(geom2);
+ const long body1 = mSpaceImp->FetchBody(obj1);
+ const long body2 = mSpaceImp->FetchBody(obj2);
- if (
- (b1) && (b2) &&
- (dAreConnectedExcluding(b1,b2,dJointTypeContact))
- )
+ if (mSpaceImp->AreConnectedWithJoint(body1, body2))
{
return;
}
// if obj1 and obj2 are in a space that disabled inner collision,
// reject the collision
- const dSpaceID s1 = dGeomGetSpace(geom1);
- const dSpaceID s2 = dGeomGetSpace(geom2);
+ const long s1 = mSpaceImp->FetchSpace(obj1);
+ const long s2 = mSpaceImp->FetchSpace(obj2);
// get shared pointers to the two corresponding Collider nodes first
shared_ptr<Collider> collider = Collider::GetCollider(obj1);
@@ -149,35 +132,12 @@
}
}
- // dSpaceCollide(), is guaranteed to pass all potentially
- // intersecting geom pairs to the callback function, but depending
- // on the internal algorithms used by the space it may also make
- // mistakes and pass non-intersecting pairs. Thus we can not
- // expect that dCollide() will return contacts for every pair
- // passed to the callback.
- static const int nContacts = 4;
- static dContact contacts[nContacts];
-
- int n = dCollide (geom1, geom2, nContacts,
- &contacts[0].geom, sizeof(dContact));
-
- if (n == 0)
- {
- return;
- }
-
-
- for (int i=0;i<n;++i)
- {
- // notify the collider nodes
- collider->OnCollision(collidee,(GenericContact&) contacts[i],Collider::CT_DIRECT);
- collidee->OnCollision(collider,(GenericContact&) contacts[i],Collider::CT_SYMMETRIC);
- }
+ mSpaceImp->CollideInternal(collider, collidee, obj1, obj2);
}
void Space::OnUnlink()
{
- mSpaceImp->DisableInnerCollision(false);
+ DisableInnerCollision(false);
PhysicsObject::OnUnlink();
}
@@ -193,50 +153,127 @@
spaceID = space->GetSpaceID();
}
- mODESpace = dHashSpaceCreate((dSpaceID) spaceID);
-
- shared_ptr<ODESpace> odespace = shared_static_cast<ODESpace>(mSpaceImp);
- odespace->mODESpace = mODESpace;
+ mSpaceID = mSpaceImp->CreateSpace(spaceID);
}
long Space::GetParentSpaceID()
{
- return mSpaceImp->GetParentSpaceID();
+ if (mSpaceID == 0)
+ {
+ return 0;
+ }
+
+ return mSpaceImp->GetParentSpaceID(mSpaceID);
}
bool Space::IsGlobalSpace()
{
- return mSpaceImp->IsGlobalSpace();
+ return
+ (
+ (mSpaceID != 0) &&
+ (GetParentSpaceID() == 0)
+ );
}
bool Space::ConstructInternal()
{
- return mSpaceImp->ConstructInternal();
+ mContactGroupID = mSpaceImp->ConstructInternal();
+
+ return (mContactGroupID != 0);
}
void Space::PostPhysicsUpdateInternal()
{
- mSpaceImp->PostPhysicsUpdateInternal();
+ mSpaceImp->PostPhysicsUpdateInternal(mContactGroupID);
}
void Space::DestroySpaceObjects()
{
- mSpaceImp->scene = GetScene();
-
- mSpaceImp->DestroySpaceObjects();
+ boost::shared_ptr<Scene> scene = GetScene();
+
+ if (scene.get() == 0)
+ {
+ return;
+ }
+
+ TLeafList objects;
+ const bool recursive = true;
+ scene->ListChildrenSupportingClass<PhysicsObject>(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<PhysicsObject> object = shared_static_cast<PhysicsObject>(*iter);
+ if (object == self)
+ {
+ continue;
+ }
+
+ // destroy objects registered to this space; the top level
+ // space object also destroy any other ODE object
+ const long parentSpace = object->GetParentSpaceID();
+ if (
+ (
+ (globalSpace) &&
+ (parentSpace == 0)
+ ) ||
+ (parentSpace == mSpaceID)
+ )
+ {
+ object->DestroyPhysicsObject();
+ }
+ }
}
void Space::DestroyPhysicsObject()
{
- mSpaceImp->DestroyPhysicsObject();
+ if (mSpaceID == 0)
+ {
+ return;
+ }
+
+ // make sure that all objects registered to this space are destroyed
+ // before this space. Any other order provokes a segfault in ODE.
+ DestroySpaceObjects();
+
+ mSpaceImp->DestroySpace(mSpaceID, mContactGroupID);
+
+ mSpaceID = 0;
+ mContactGroupID = 0;
}
void Space::DisableInnerCollision(bool disable)
{
- mSpaceImp->DisableInnerCollision(disable);
+ if (mSpaceID == 0)
+ {
+ return;
+ }
+
+ if (disable)
+ {
+ gDisabledInnerCollisionSet.insert(mSpaceID);
+ return;
+ }
+
+ TSpaceIdSet::iterator iter = gDisabledInnerCollisionSet.find(mSpaceID);
+ if (iter == gDisabledInnerCollisionSet.end())
+ {
+ return;
+ }
+
+ gDisabledInnerCollisionSet.erase(iter);
}
bool Space::GetDisableInnerCollision() const
{
- return mSpaceImp->GetDisableInnerCollision();
+ TSpaceIdSet::const_iterator iter
+ = gDisabledInnerCollisionSet.find(mSpaceID);
+
+ return (iter != gDisabledInnerCollisionSet.end());
}
Modified: branches/multiphys/spark/lib/oxygen/physicsserver/space.h
===================================================================
--- branches/multiphys/spark/lib/oxygen/physicsserver/space.h 2010-01-13 13:21:31 UTC (rev 142)
+++ branches/multiphys/spark/lib/oxygen/physicsserver/space.h 2010-01-14 09:15:14 UTC (rev 143)
@@ -42,7 +42,7 @@
class OXYGEN_API Space : public PhysicsObject
{
public:
- typedef std::set<dSpaceID> TSpaceIdSet;
+ typedef std::set<long> TSpaceIdSet;
public:
Space();
@@ -76,10 +76,14 @@
/** query disabled inner collision flag */
bool GetDisableInnerCollision() const;
+
+ /** callback to handle a potential collision between two contained
+ geoms. It will look up and notify the corresponding colliders
+ for a potential collision.
+ */
+ void HandleCollide(long obj1, long obj2);
protected:
- static void collisionNearCallback (void *data, dGeomID obj1, dGeomID obj2);
-
/** unregisters the managed Space of the Scene. */
virtual void OnUnlink();
@@ -89,18 +93,12 @@
/** calls ODE's collision detection for this space if internal collision
* detection is enabled for this space.
*/
- void Collide(dSpaceID space);
+ void Collide(long space);
- /** callback to handle a potential collision between two contained
- geoms. It will look up and notify the corresponding colliders
- for a potential collision.
- */
- void HandleCollide(long obj1, long obj2);
-
/** handle the collision between two geoms from which at least one
is a space geom
*/
- void HandleSpaceCollide(dGeomID obj1, dGeomID obj2);
+ void HandleSpaceCollide(long obj1, long obj2);
/** creates them managed ODE space and a contact joint group */
virtual bool ConstructInternal();
@@ -116,11 +114,13 @@
//
// Members
//
-private:
+private:
boost::shared_ptr<SpaceInt> mSpaceImp;
- /** the managed ODE space */
- dSpaceID mODESpace;
+ long mContactGroupID;
+
+ /** the managed space */
+ long mSpaceID;
private:
/** set of spaces with disabled inner collision */
Modified: branches/multiphys/spark/lib/oxygen/physicsserver/staticphysicsmethods_ode.cpp
===================================================================
--- branches/multiphys/spark/lib/oxygen/physicsserver/staticphysicsmethods_ode.cpp 2010-01-13 13:21:31 UTC (rev 142)
+++ branches/multiphys/spark/lib/oxygen/physicsserver/staticphysicsmethods_ode.cpp 2010-01-14 09:15:14 UTC (rev 143)
@@ -22,6 +22,7 @@
#include <oxygen/physicsserver/collider.h>
#include <oxygen/physicsserver/joint.h>
#include <oxygen/physicsserver/rigidbody.h>
+#include <oxygen/physicsserver/space.h>
#include <oxygen/physicsserver/ode/odewrapper.h>
using namespace oxygen;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
