Navigation

← Previous Changeset
Next Changeset →

Changeset 186

Timestamp:

02/27/2010 09:37:52 PM (2 years ago)

Author:

mceier

Message:

Collision detection support

Signed-off-by: Mariusz Ceier <mceier@gmail.com>

Files:

trunk/include/waterworld/sim2/Animat.h (modified) (3 diffs)
trunk/include/waterworld/sim2/CollisionSensor.h (modified) (2 diffs)
trunk/include/waterworld/sim2/ContactPoint.h (modified) (2 diffs)
trunk/include/waterworld/sim2/ContactPoints.h (modified) (2 diffs)
trunk/include/waterworld/sim2/Types.h (modified) (1 diff)
trunk/include/waterworld/sim2/World.h (modified) (2 diffs)
trunk/src/CMakeLists.txt (modified) (1 diff)
trunk/src/waterworld/sim2/Animat.cpp (modified) (4 diffs)
trunk/src/waterworld/sim2/CollisionSensor.cpp (modified) (1 diff)
trunk/src/waterworld/sim2/ContactPoint.cpp (modified) (3 diffs)
trunk/src/waterworld/sim2/World.cpp (modified) (6 diffs)
trunk/src/waterworld4.cpp (modified) (3 diffs)
trunk/src/waterworld5.cpp (copied) (copied from trunk/src/waterworld4.cpp) (3 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/include/waterworld/sim2/Animat.h

r185	r186
59	59	*/
60	60	boost::intrusive_ptr<PhysicalBody> m_body;
61		/**
62		* Pointer to a function called on collision detect
63		*/
64		~~void (*collision)();~~
65		/**
66		* On/Off collision detection for this body/animat
67		*/
68		~~bool cde; //CollisiondDetectionEnabled~~
69	61	/**
70	62	* True if collisions are enabled ...
…	…
72	64	bool m_enabled_collisions;
73	65	public:
74		/**
75		* \Set a pointer to a function called on collision detect
76		*/
77		~~void setCollisionFunction(void (*)());~~
78
79		/**
80		* \Get a pointer to a function called on collision detect
81		*/
82		~~void* getCollisionFunction();~~
83
84		/**
85		* \Set on/of collision detectcion
86		*/
87		~~void setCollisionEnabled(bool);~~
88
89		/**
90		* \Get on/of collision detect
91		*/
92		~~bool isCollisionEnabled();~~
93
94	66	/**
95	67	* \return constant chemical signals that this animat "emits" ( read-only )
…	…
143	115	* Enable collisions - use getContactPoints method to access collision points
144	116	*/
145		void enableCollisions();
	117	void enableCollisions(boost::intrusive_ptr<World> world);
146	118	/**
147	119	* Disable collisions
148	120	*/
149		void disableCollisions();
	121	void disableCollisions(boost::intrusive_ptr<World> world);
150	122	/**
151	123	* \return True if detection of collisions for this animat is enabled

trunk/include/waterworld/sim2/CollisionSensor.h

r185	r186
12	12
13	13	#include "Sensor.h"
	14	#include "ContactPoint.h"
14	15
15	16	namespace waterworld
…	…
31	32	*/
32	33	virtual void onCollision(boost::intrusive_ptr<Animat> animat1,
33		boost::intrusive_ptr<Animat> animat2,
34		Position contactPoint,
	34	ContactPoint const &contactPoint,
35	35	boost::intrusive_ptr<World> world,
36	36	real_t dt) = 0;

trunk/include/waterworld/sim2/ContactPoint.h

r185	r186
20	20	{
21	21	boost::intrusive_ptr<Animat> m_animat;
22		Position m_contact_point;
	22	Position m_contact_position;
	23	vec3r m_contact_normal;
23	24	public:
24	25	/**
25	26	* \param animat Colliding animat
26		* \param contactPoint Contact point
	27	* \param contactPosition Contact position
	28	* \param contactNormal Contact normal
27	29	*/
28	30	ContactPoint(boost::intrusive_ptr<Animat> animat,
29		Position contactPoint);
	31	Position contactPosition,
	32	vec3r contactNormal);
30	33	ContactPoint(ContactPoint const &cp);
31	34	ContactPoint &operator=(ContactPoint const &cp);
…	…
35	38	boost::intrusive_ptr<Animat> getCollidingAnimat() const;
36	39	/**
37		* \return Contact po~~int~~
	40	* \return Contact position
38	41	*/
39		Position getContactPoint() const;
	42	Position getContactPosition() const;
	43	/**
	44	* \return Contact normal
	45	*/
	46	vec3r getContactNormal() const;
40	47	virtual ~ContactPoint();
41	48	};

trunk/include/waterworld/sim2/ContactPoints.h

r185	r186
3	3
4	4	#include "ContactPoint.h"
5		~~#include <boost/smart_ptr.hpp>~~
6	5	#include <vector>
7	6
…	…
11	10	* List of contact points
12	11	*/
13		typedef std::vector<~~boost::intrusive_ptr<ContactPoint>~~ > ContactPoints;
	12	typedef std::vector<ContactPoint> ContactPoints;
14	13	}
15	14

trunk/include/waterworld/sim2/Types.h

r175	r186
33	33
34	34	/**
	35	* Create Vec3
	36	*/
	37	template<typename T>
	38	inline boost::numeric::ublas::bounded_vector<T,3> makeVec3(T x,T y,T z)
	39	{
	40	boost::numeric::ublas::bounded_vector<T,3> tmp;
	41	tmp(0) = x;
	42	tmp(1) = y;
	43	tmp(2) = z;
	44	return tmp;
	45	}
	46
	47	/**
35	48	* Create force
36	49	*/

trunk/include/waterworld/sim2/World.h

r182	r186
15	15	#include <boost/thread.hpp>
16	16
	17	/**
	18	* PAL classes
	19	*/
	20	class palPhysics;
	21	class palCollisionDetection;
	22
17	23	namespace waterworld
18	24	{
…	…
30	36	void stopEventsThread();
31	37	void step(real_t dt);
	38	palPhysics *getPhysics() const;
	39	palCollisionDetection *getCollisionDetection() const;
32	40	boost::intrusive_ptr<PhysicalBody> createAnimatsBody(
33	41	boost::intrusive_ptr<Animat> animat,

trunk/src/CMakeLists.txt

r175	r186
19	19	QuitEventHandler.cpp)
20	20	TARGET_LINK_LIBRARIES(WaterWorld3 ${WATERWORLD_LIBRARY} ${WATERWORLD_LIBRARIES})
	21	ADD_EXECUTABLE(WaterWorld5
	22	waterworld5.cpp
	23	SerializeEventHandler.cpp
	24	QuitEventHandler.cpp)
	25	TARGET_LINK_LIBRARIES(WaterWorld5 ${WATERWORLD_LIBRARY} ${WATERWORLD_LIBRARIES})
21	26	ELSE(USE_SIM2)
22	27	ADD_EXECUTABLE(WaterWorld2 waterworld2.cpp)

trunk/src/waterworld/sim2/Animat.cpp

r185	r186
1	1	#include <waterworld/sim2/Animat.h>
	2	#include <pal/palCollision.h>
2	3
3	4	namespace waterworld
…	…
51	52	{
52	53	}
53
54		~~void Animat::setCollisionFunction(void ptr())~~
55		{
56		~~collision = ptr;~~
57		}
58
59		~~void* Animat::getCollisionFunction()~~
60		{
61		~~return (void*)collision;~~
62		}
63
64		~~void Animat::setCollisionEnabled(bool e)~~
65		{
66		~~cde = e;~~
67		}
68
69		~~bool Animat::isCollisionEnabled()~~
70		{
71		~~return cde;~~
72		}
73	54
74	55	ChemicalSignals const &Animat::getChemicalSignals() const
…	…
133	114	void Animat::setPhysicalBody(boost::intrusive_ptr<PhysicalBody> newBody)
134	115	{
	116	if (m_body!=newBody)
	117	m_enabled_collisions = false;
135	118	m_body = newBody;
136	119	}
137	120
138		void Animat::enableCollisions()
	121	void Animat::enableCollisions(boost::intrusive_ptr<World> world)
139	122	{
140		m_enabled_collisions = true;
	123	if ((getPhysicalBody())&&(getPhysicalBody()->getBody()))
	124	{
	125	palCollisionDetection *pcd = world->getCollisionDetection();
	126	if(pcd)
	127	{
	128	pcd->NotifyCollision(getPhysicalBody()->getBody(),true); //enable collision detection for the body
	129	m_enabled_collisions = true;
	130	}
	131	}
141	132	}
142	133
143		void Animat::disableCollisions()
	134	void Animat::disableCollisions(boost::intrusive_ptr<World> world)
144	135	{
145		m_enabled_collisions = false;
	136	if ((getPhysicalBody())&&(getPhysicalBody()->getBody()))
	137	{
	138	palCollisionDetection *pcd = world->getCollisionDetection();
	139	if(pcd)
	140	{
	141	pcd->NotifyCollision(getPhysicalBody()->getBody(),false); //disable collision detection for the body
	142	m_enabled_collisions = false;
	143	}
	144	}
146	145	}
147	146
…	…
157	156	void Animat::update(boost::intrusive_ptr<World> world, real_t dt)
158	157	{
	158	m_contact_points.clear();
	159	if (hasEnabledCollisions())
	160	{
	161	palContact contacts;
	162	world->getCollisionDetection()->GetContacts(getPhysicalBody()->getBody(),contacts);
	163	m_contact_points.reserve(contacts.m_ContactPoints.size());
	164	for(PAL_VECTOR<palContactPoint>::iterator i=contacts.m_ContactPoints.begin();
	165	i!=contacts.m_ContactPoints.end();++i)
	166	{
	167	m_contact_points.push_back(ContactPoint(((PhysicalBody*)i->m_pBody1->GetUserData())->getAnimat(),
	168	makePosition(i->m_vContactPosition[0],i->m_vContactPosition[1],i->m_vContactPosition[2]),
	169	makeVec3(i->m_vContactNormal[0], i->m_vContactNormal[1],i->m_vContactNormal[2])));
	170	}
	171	}
159	172	for(Sensors::iterator i=m_sensors.begin();i!=m_sensors.end();++i)
160	173	(*i)->update(this, world, dt);

trunk/src/waterworld/sim2/CollisionSensor.cpp

r185	r186
28	28	ContactPoints cp(animat->getContactPoints());
29	29	for(ContactPoints::iterator i=cp.begin();i!=cp.end();++i)
30		onCollision(animat,~~(i)->getCollidingAnimat(),(i)->getContactPoint()~~,world,dt);
	30	onCollision(animat,*i,world,dt);
31	31	}
32	32	}

trunk/src/waterworld/sim2/ContactPoint.cpp

r185	r186
5	5
6	6	ContactPoint::ContactPoint(boost::intrusive_ptr<Animat> animat,
7		Position contactPoint) :
8		m_animat(animat), m_contact_point(contactPoint)
	7	Position contactPosition,
	8	vec3r contactNormal) :
	9	m_animat(animat),
	10	m_contact_position(contactPosition),
	11	m_contact_normal(contactNormal)
9	12	{
10	13	}
…	…
13	16	IntrusivePtrBase(cp),
14	17	m_animat(cp.m_animat),
15		m_contact_point(cp.m_contact_point)
	18	m_contact_position(cp.m_contact_position),
	19	m_contact_normal(cp.m_contact_normal)
16	20	{
	21	}
	22
	23	ContactPoint &ContactPoint::operator=(ContactPoint const &cp)
	24	{
	25	if(this!=&cp)
	26	{
	27	m_animat = cp.m_animat;
	28	m_contact_position = cp.m_contact_position;
	29	m_contact_normal = cp.m_contact_normal;
	30	}
	31	return *this;
17	32	}
18	33
…	…
22	37	}
23	38
24		Position ContactPoint::getContactPo~~int~~() const
	39	Position ContactPoint::getContactPosition() const
25	40	{
26		return m_contact_point;
	41	return m_contact_position;
	42	}
	43
	44	vec3r ContactPoint::getContactNormal() const
	45	{
	46	return m_contact_normal;
27	47	}
28	48

trunk/src/waterworld/sim2/World.cpp

r184	r186
9	9	namespace
10	10	{
	11	/* TODO: Put this code in separate class */
11	12	static palPhysics *g_physics = NULL;
12		static palCollisionDetection *pcd = NULL;
	13	static palCollisionDetection *g_pcd = NULL;
13	14
14	15	static void initPhysics()
…	…
21	22	if (g_physics)
22	23	{
23		pcd = dynamic_cast<palCollisionDetection *>(g_physics);
	24	g_pcd = dynamic_cast<palCollisionDetection *>(g_physics);
24	25	palPhysicsDesc tmpDesc;
25	26	tmpDesc.m_vGravity[0] = palPhysicsDesc::DEFAULT_GRAVITY_X;
…	…
35	36	// PF->SetActivePhysics(g_physics); // Does not work
36	37	return g_physics;
	38	}
	39
	40	static palCollisionDetection *getCollisionDetection()
	41	{
	42	return g_pcd;
37	43	}
38	44	}
…	…
56	62	void World::step(real_t dt)
57	63	{
58		~~for(Animats::iterator i=m_animats.begin();i!=m_animats.end();++i)~~
59		{
	64	Animats animats(m_animats);
	65	for(Animats::iterator i=animats.begin();i!=animats.end();++i)
60	66	(*i)->update(this, dt);
61
62		~~if((*i)->isCollisionEnabled())~~
63		{
64		~~palContact contact;~~
65		~~pcd->GetContacts((palBodyBase )(i)->getPhysicalBody()->getBody(),contact);~~
66		}
67		}
68	67	palPhysics *tmp = getPhysics();
69	68	if (tmp!=NULL)
…	…
91	90	}
92	91
	92	palPhysics *World::getPhysics() const
	93	{
	94	return waterworld::getPhysics();
	95	}
	96
	97	palCollisionDetection *World::getCollisionDetection() const
	98	{
	99	return waterworld::getCollisionDetection();
	100	}
	101
93	102	boost::intrusive_ptr<PhysicalBody> World::createAnimatsBody(
94	103	boost::intrusive_ptr<Animat> animat,
…	…
100	109	body->setBody(sphere);
101	110	animat->setPhysicalBody(body);
102
103		~~if(pcd)pcd->NotifyCollision((palBodyBase *) sphere,true); //enable collision detection for the body~~
104
105	111	return body;
106	112	}

trunk/src/waterworld4.cpp

r179	r186
1	1	#include <waterworld/sim2/World.h>
	2	#include <waterworld/sim2/CollisionSensor.h>
2	3	#include <gui2/Application.h>
3	4	#include "EventTypes.h"
…	…
29	30	setForce(20.0*makeForce(cos(m_alpha), sin(m_alpha), 0));
30	31	//cout << "updating force: alpha = " << m_alpha << endl;
	32	}
	33	};
	34
	35	class MyCollSensor : public waterworld::CollisionSensor
	36	{
	37	public:
	38	void onCollision(boost::intrusive_ptr<waterworld::Animat> animat,
	39	waterworld::ContactPoint const &cp,
	40	boost::intrusive_ptr<waterworld::World> world,
	41	waterworld::real_t dt)
	42	{
	43	using namespace std;
	44	using namespace waterworld;
	45	Position p(cp.getContactPosition());
	46	cout << "Collision at: " << p(0) << ',' << p(1) << ',' << p(2) << endl;
	47	cout << "ID1: " << animat->getID() << ' ' << "ID2: " << cp.getCollidingAnimat()->getID() << endl;
	48	world->getAnimats().erase(cp.getCollidingAnimat());
31	49	}
32	50	};
…	…
74	92	animat4->getActuators().push_back(new Actuator(makeForce(0.0,-0.1*palPhysicsDesc::DEFAULT_GRAVITY_Y,0.0), makePosition(0,0,0)));
75	93	myWorld->getAnimats().insert(animat4);
	94
	95	animat->enableCollisions(myWorld);
	96	animat->getSensors().push_back(new MyCollSensor());
	97
76	98	gui::Application app(myWorld);
77	99	quit=!app.init(640,480,16);

trunk/src/waterworld5.cpp

r179	r186
1	1	#include <waterworld/sim2/World.h>
2		#include <~~gui2/Application~~.h>
	2	#include <waterworld/sim2/CollisionSensor.h>
3	3	#include "EventTypes.h"
4	4	#include "SerializeEventHandler.h"
…	…
7	7	#include <iostream>
8	8	#include <pal/palFactory.h>
9		~~#include <cmath>~~
10	9
11		class ~~SimpleActuator : public waterworld::Actuat~~or
	10	class MyCollSensor : public waterworld::CollisionSensor
12	11	{
13		~~waterworld::real_t m_alpha;~~
14		~~waterworld::real_t m_omega;~~
15	12	public:
16		SimpleActuator(waterworld::real_t current, waterworld::real_t omega) :
17		waterworld::Actuator(waterworld::makeForce(0.002,0,0),
18		waterworld::makePosition(0,0,0)),
19		m_alpha(current), m_omega(omega)
20		{
21		}
22		void update(boost::intrusive_ptr<waterworld::Animat> animat,
23		boost::intrusive_ptr<waterworld::World> world,
	13	void onCollision(boost::intrusive_ptr<waterworld::Animat> animat,
	14	waterworld::ContactPoint const &cp,
	15	boost::intrusive_ptr<waterworld::World> world,
24	16	waterworld::real_t dt)
25	17	{
	18	using namespace std;
26	19	using namespace waterworld;
27		~~using namespace std~~;
28		~~m_alpha += m_omega*dt~~;
29		~~setForce(20.0*makeForce(cos(m_alpha), sin(m_alpha), 0))~~;
30		~~//cout << "updating force: alpha = " << m_alpha << endl~~;
	20	Position p(cp.getContactPosition());
	21	cout << "Collision at: " << p(0) << ',' << p(1) << ',' << p(2) << endl;
	22	cout << "ID1: " << animat->getID() << ' ' << "ID2: " << cp.getCollidingAnimat()->getID() << endl;
	23	world->getAnimats().erase(cp.getCollidingAnimat());
31	24	}
32	25	};
…	…
74	67	animat4->getActuators().push_back(new Actuator(makeForce(0.0,-0.1*palPhysicsDesc::DEFAULT_GRAVITY_Y,0.0), makePosition(0,0,0)));
75	68	myWorld->getAnimats().insert(animat4);
76		~~gui::Application app~~(myWorld);
77		~~quit=!app.init(640,480,16~~);
	69	animat->enableCollisions(myWorld);
	70	animat->getSensors().push_back(new MyCollSensor());
78	71	while(!quit)
79	72	{
80	73	for(unsigned int i=0;(!quit) && (i<100);++i)
81		{
82	74	myWorld->step(0.001);
83		~~app.draw();~~
84		}
85	75	myWorld->getEventsQueue()->addEvent(new Event(SerializeEventType));
86	76	}

Navigation

Changeset 186

Legend:

Download in other formats: