Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/physics/src/ogreode/OgreOdeWorld.cpp @ 1919

Last change on this file since 1919 was 1919, checked in by rgrieder, 16 years ago

Added OgreODE to our source repository because already we really need the newest version. And there is no hope to find any packages under linux.
The files included should compile and link with Ogre 1.4/1.6 and ODE 0.9/0.10. I was only able to test Ogre 1.4 and ODE 0.9/.10 under msvc until now.
  • Property svn:eol-style set to native
File size: 9.3 KB
Line 
1
2#include "OgreOdePrecompiledHeaders.h"
3
4#include "OgreOdeWorld.h"
5#include "OgreOdeBody.h"
6#include "OgreOdeJoint.h"
7#include "OgreOdeGeometry.h"
8#include "OgreOdeSpace.h"
9#include "OgreOdeDebugObject.h"
10
11using namespace OgreOde;
12using namespace Ogre;
13
14CollisionListener* World::_collision_listener = 0;
15//------------------------------------------------------------------------------------------------
16void World::setCollisionListener(CollisionListener* collision_listener)
17{
18        _collision_listener = collision_listener;
19}
20//------------------------------------------------------------------------------------------------
21CollisionListener* World::getCollisionListener()
22{
23        return _collision_listener;
24}
25//------------------------------------------------------------------------------------------------
26World::World(SceneManager* manager) :
27    _show_debug_geoms (false),
28    _show_debug_contact (false),
29    _manager (manager)
30{
31#if ODE_VERSION_MINOR > 9
32        dInitODE2(0);
33        dAllocateODEDataForThread(dAllocateMaskAll);
34#endif
35
36
37        _world = dWorldCreate();
38        _contacts = dJointGroupCreate(0);
39
40        _default_space = new HashTableSpace(this);
41        _default_space->setAutoCleanup(false);
42        _default_space->setInternalCollisions(true);
43
44        setDamping(0.0,0.0);
45        setHistorySize (1);
46
47
48}
49//------------------------------------------------------------------------------------------------
50void World::setHistorySize(size_t historySize)
51{
52        _history_size = historySize;
53
54        MaintainedItemIterator<Body> it = _body_list.getIterator();
55        while(!it.end ())
56        {
57                Body * const b = (Body *) (it.getNext ());
58                b->_historyResize(historySize);
59        }
60
61}
62//------------------------------------------------------------------------------------------------
63size_t World::getHistorySize() const 
64{
65        return _history_size;
66}
67//------------------------------------------------------------------------------------------------
68void World::setGravity(const Ogre::Vector3& gravity)
69{
70        dWorldSetGravity(_world,(dReal)gravity.x,(dReal)gravity.y,(dReal)gravity.z);
71}
72//------------------------------------------------------------------------------------------------
73const Ogre::Vector3& World::getGravity()
74{
75        dVector3 g;
76        dWorldGetGravity(_world,g);
77        _gravity.x = (Real)g[0];
78        _gravity.y = (Real)g[1];
79        _gravity.z = (Real)g[2];
80        return _gravity;
81}
82//------------------------------------------------------------------------------------------------
83void World::setERP(Real erp)
84{
85        dWorldSetERP(_world,(dReal)erp);
86}
87//------------------------------------------------------------------------------------------------
88Real World::getERP()
89{
90        return (Real)dWorldGetERP(_world);
91}
92//------------------------------------------------------------------------------------------------
93void World::setCFM(Real cfm)
94{
95        dWorldSetCFM(_world,(dReal)cfm);
96}
97//------------------------------------------------------------------------------------------------
98Real World::getCFM()
99{
100        return (Real)dWorldGetCFM(_world);
101}
102//------------------------------------------------------------------------------------------------
103void World::setAutoSleep(bool auto_sleep)
104{
105        dWorldSetAutoDisableFlag(_world,(auto_sleep)?1:0);
106}
107//------------------------------------------------------------------------------------------------
108bool World::getAutoSleep()
109{
110        return (dWorldGetAutoDisableFlag(_world))?true:false;
111}
112//------------------------------------------------------------------------------------------------
113void World::setAutoSleepLinearThreshold(Real linear_threshold)
114{
115        dWorldSetAutoDisableLinearThreshold(_world,(dReal)linear_threshold);
116}
117//------------------------------------------------------------------------------------------------
118Real World::getAutoSleepLinearThreshold()
119{
120        return (Real)dWorldGetAutoDisableLinearThreshold(_world);
121}
122//------------------------------------------------------------------------------------------------
123void World::setAutoSleepAngularThreshold(Real angular_threshold)
124{
125        dWorldSetAutoDisableAngularThreshold(_world,(dReal)angular_threshold);
126}
127//------------------------------------------------------------------------------------------------
128Real World::getAutoSleepAngularThreshold()
129{
130        return (Real)dWorldGetAutoDisableAngularThreshold(_world);
131}
132//------------------------------------------------------------------------------------------------
133void World::setAutoSleepSteps(int steps)
134{
135        dWorldSetAutoDisableSteps(_world,steps);
136}
137//------------------------------------------------------------------------------------------------
138int World::getAutoSleepSteps()
139{
140        return dWorldGetAutoDisableSteps(_world);
141}
142//------------------------------------------------------------------------------------------------
143void World::setAutoSleepTime(Real time)
144{
145        dWorldSetAutoDisableTime(_world,(dReal)time);
146}
147//------------------------------------------------------------------------------------------------
148Real World::getAutoSleepTime()
149{
150        return (Real)dWorldGetAutoDisableTime(_world);
151}
152//------------------------------------------------------------------------------------------------
153void World::setAutoSleepAverageSamplesCount(unsigned int time)
154{
155    dWorldSetAutoDisableAverageSamplesCount(_world, time);
156}
157//------------------------------------------------------------------------------------------------
158size_t World::getAutoSleepAverageSamplesCount()
159{
160    return (Real)dWorldGetAutoDisableAverageSamplesCount(_world);
161}
162//------------------------------------------------------------------------------------------------
163void World::setContactCorrectionVelocity(Real velocity)
164{
165        dWorldSetContactMaxCorrectingVel(_world,(dReal)velocity);
166}
167//------------------------------------------------------------------------------------------------
168void World::setContactSurfaceLayer(Real layer)
169{
170        dWorldSetContactSurfaceLayer(_world,(dReal)layer);
171}
172
173//------------------------------------------------------------------------------------------------
174void World::collisionCallback(void *data,dGeomID geom_a,dGeomID geom_b)
175{
176        const bool a_space = (dGeomIsSpace(geom_a))?true:false;
177        const bool b_space = (dGeomIsSpace(geom_b))?true:false;
178       
179        void* const ptr_a = dGeomGetData(geom_a);
180        void* const ptr_b = dGeomGetData(geom_b);
181
182        if(a_space  || b_space )
183        {
184                // Collide a space with a space
185                if(a_space && b_space) 
186                        static_cast<Space*>(ptr_a)->collide(static_cast<Space*>(ptr_b),data);
187                else if(a_space) 
188                        static_cast<Space*>(ptr_a)->collide(static_cast<Geometry*>(ptr_b),data);
189                else 
190                        static_cast<Space*>(ptr_b)->collide(static_cast<Geometry*>(ptr_a),data);
191
192                // Collide geometries internal to the spaces
193                if(a_space) 
194            static_cast<Space*>(ptr_a)->collide(data);
195
196                if(b_space) 
197            static_cast<Space*>(ptr_b)->collide(data);
198        }
199    else
200        {
201                // Collide a geom with a geom, i.e. generate contacts
202                static_cast<Geometry*>(ptr_a)->collide(static_cast<Geometry*>(ptr_b),_collision_listener);
203        }
204}
205//------------------------------------------------------------------------------------------------
206Body* World::findBody(SceneNode* node)
207{
208        Body* body = 0;
209        for(int i = 0;i < node->numAttachedObjects();i++)
210        {
211                MovableObject* obj = node->getAttachedObject(i);
212                if(obj)
213                {
214                        if(obj->getMovableType() == Ogre::String("OgreOde::Body"))
215                        {
216                                body = static_cast<Body*>(obj);
217                                break;
218                        }
219                }
220        }
221        return body;
222}
223//------------------------------------------------------------------------------------------------
224Body* World::findBody(const Ogre::String& name)
225{
226        Body *b = 0;
227        MaintainedItemIterator<Body> it = _body_list.getIterator();
228        while(!it.end ())
229        {
230                b = (Body*) (it.getNext ());
231                if(b->getName() == name) 
232                        return b;
233        }
234        return 0;
235}
236//------------------------------------------------------------------------------------------------
237void World::setDefaultSpace(Space* space)
238{
239        delete _default_space;
240        _default_space = space;
241}
242//------------------------------------------------------------------------------------------------
243void World::setQuickStepIterations(int iterations)
244{
245        dWorldSetQuickStepNumIterations(_world,iterations);
246}
247//------------------------------------------------------------------------------------------------
248int World::getQuickStepIterations()
249{
250        return dWorldGetQuickStepNumIterations(_world);
251}
252//------------------------------------------------------------------------------------------------
253void World::setShowDebugGeometries(bool show)
254{
255        _body_list.setDebug(show);
256        _geometry_list.setDebug(show);
257        _show_debug_geoms = show;
258}
259//------------------------------------------------------------------------------------------------
260void World::setShowDebugContact(bool show)
261{
262    _geometry_list.setDebugContact(show);
263    _show_debug_contact = show;
264}
265//------------------------------------------------------------------------------------------------
266void World::setDamping(Real linear_damping,Real angular_damping)
267{
268        _linear_damping = -(dReal)linear_damping;
269        _angular_damping = -(dReal)angular_damping;
270}
271//------------------------------------------------------------------------------------------------
272Real World::getLinearDamping()
273{
274        return -(Real)_linear_damping;
275}
276//------------------------------------------------------------------------------------------------
277Real World::getAngularDamping()
278{
279        return -(Real)_angular_damping;
280}
281//------------------------------------------------------------------------------------------------
282World::~World()
283{
284        delete _default_space;
285        dJointGroupDestroy(_contacts);
286    dWorldDestroy(_world);
287    dCloseODE();
288}
Note: See TracBrowser for help on using the repository browser.