Project

General

Profile

SO3Engine
OgreNewt_Body.cpp
Go to the documentation of this file.
1#include "External/ogrenewt/OgreNewt_Stdafx.h"
2#include "External/ogrenewt/OgreNewt_Body.h"
3#include "External/ogrenewt/OgreNewt_World.h"
4#include "External/ogrenewt/OgreNewt_Collision.h"
5#include "External/ogrenewt/OgreNewt_Tools.h"
6
7#include "SO3Utils/SO3Euler.h"
8
9
10namespace OgreNewt
11{
12
13 Body::Body(World* const W, const OgreNewt::CollisionPtr& col, int bodytype, bool trigger) :
14 m_world(W)
15 {
16 m_collision = col;
17 m_type = bodytype;
18 m_node = 0;
19 m_matid = 0;
20 m_userdata = 0;
21
22 m_triggerController = 0;
23 m_forcecallback = 0;
24 m_triggerEnterCallback = 0;
25 m_triggerInsideCallback = 0;
26 m_triggerExitCallback = 0;
27 //m_transformcallback = 0;
28 m_nodeupdatenotifycallback = 0;
29 m_nodeupdatejointnotifycallback = 0;
30
31 //m_nodeupdateneeded = false;
32
33 m_nodePosit = Ogre::Vector3(0.0f, 0.0f, 0.0f);
34 m_curPosit = Ogre::Vector3(0.0f, 0.0f, 0.0f);
35 m_prevPosit = Ogre::Vector3(0.0f, 0.0f, 0.0f);
36 m_curRotation = Ogre::Quaternion::IDENTITY;
37 m_prevRotation = Ogre::Quaternion::IDENTITY;
38 m_nodeRotation = Ogre::Quaternion::IDENTITY;
39 m_scale = Ogre::Vector3::UNIT_SCALE;
40
41 //Newton 2.30
42 dFloat matrix[16];
43 OgreNewt::Converters::QuatPosToMatrix(m_curRotation, m_nodePosit, &matrix[0]);
44
45 m_world->waitForUpdateToFinish();
46
47 if (trigger)
48 {
49 m_triggerController = m_world->CreateController(&matrix[0], col->getNewtonCollision());
50 WorldTriggerManager::TriggerCallback* const triggerCb = (WorldTriggerManager::TriggerCallback*) m_triggerController->GetUserData();
51 triggerCb->setTriggerEnterCallback<Body>(&Body::newtonTriggerEnterCallback, this);
52 triggerCb->setTriggerInsideCallback<Body>(&Body::newtonTriggerInsideCallback, this);
53 triggerCb->setTriggerExitCallback<Body>(&Body::newtonTriggerExitCallback, this);
54 m_body = m_triggerController->GetBody();
55 }
56 else
57 {
58 m_body = NewtonCreateDynamicBody(m_world->getNewtonWorld(), col->getNewtonCollision(), &matrix[0]);
59 }
60
61 if (m_body)
62 {
63 NewtonBodySetUserData(m_body, this);
64 NewtonBodySetDestructorCallback(m_body, newtonDestructor);
65 NewtonBodySetTransformCallback(m_body, newtonTransformCallback);
66
67 //setLinearDamping(m_world->getDefaultLinearDamping() * (60.0f / m_world->getUpdateFPS()));
68 //setAngularDamping(m_world->getDefaultAngularDamping() * (60.0f / m_world->getUpdateFPS()));
69 }
70 }
71
72 Body::~Body()
73 {
74 if (m_body)
75 {
76 m_world->waitForUpdateToFinish();
77 m_forcecallback = 0;
78 m_triggerEnterCallback = 0;
79 m_triggerInsideCallback = 0;
80 m_triggerExitCallback = 0;
81 m_nodeupdatenotifycallback = 0;
82 m_nodeupdatejointnotifycallback = 0;
83
84 NewtonBodySetUserData(m_body, NULL);
85 NewtonBodySetDestructorCallback(m_body, NULL);
86 NewtonBodySetForceAndTorqueCallback(m_body, NULL);
87 NewtonBodySetTransformCallback(m_body, NULL);
88 if (m_triggerController)
89 {
90 m_world->DestroyController(m_triggerController);
91 m_triggerController = 0;
92 }
93 else
94 {
95 NewtonDestroyBody(m_body);
96 }
97
98 m_body = 0;
99 }
100 }
101
102 // destructor callback
103 void _CDECL Body::newtonDestructor(const NewtonBody* body)
104 {
105 //newton wants to destroy the body.. so first find it.
106 OgreNewt::Body* me = static_cast<OgreNewt::Body*>(NewtonBodyGetUserData(body));
107 if (me)
108 {
109 // remove destructor callback
110 NewtonBodySetDestructorCallback(body, NULL);
111 // remove the user data
112 NewtonBodySetUserData(body, NULL);
113
114 NewtonBodySetForceAndTorqueCallback(body, NULL);
115 NewtonBodySetTransformCallback(body, NULL);
116
117 me->m_forcecallback = 0;
118 me->m_triggerEnterCallback = 0;
119 me->m_triggerInsideCallback = 0;
120 me->m_triggerExitCallback = 0;
121 me->m_nodeupdatenotifycallback = 0;
122 me->m_nodeupdatejointnotifycallback = 0;
123
124 me->m_body = 0;
125 }
126 }
127
128 // transform callback
129 void _CDECL Body::newtonTransformCallback(const NewtonBody* body, const dFloat* matrix, int threadIndex)
130 {
131 Ogre::Real dot;
132 OgreNewt::Body* me;
133
134 me = static_cast<OgreNewt::Body*>(NewtonBodyGetUserData(body));
135 if (me)
136 {
137 me->m_prevPosit = me->m_curPosit;
138 me->m_prevRotation = me->m_curRotation;
139 me->m_curPosit = Ogre::Vector3(Ogre::Real(matrix[12]), Ogre::Real(matrix[13]), Ogre::Real(matrix[14]));
140
141 // use the rotation from the body
142 dVector rot;
143 NewtonBodyGetRotation(body, &rot.m_x);
144 me->m_curRotation.w = Ogre::Real(rot.m_x);
145 me->m_curRotation.x = Ogre::Real(rot.m_y);
146 me->m_curRotation.y = Ogre::Real(rot.m_z);
147 me->m_curRotation.z = Ogre::Real(rot.m_w);
148
149 dot = me->m_prevRotation.Dot(me->m_curRotation);
150
151 if (dot < 0.0f)
152 me->m_prevRotation = -1.0f * me->m_prevRotation;
153 }
154 }
155
156 void Body::newtonTriggerEnterCallback(NewtonBody* const visitor)
157 {
158 OgreNewt::Body* me = static_cast<OgreNewt::Body*>(NewtonBodyGetUserData(visitor));
159 {
160 if (m_triggerEnterCallback)
161 m_triggerEnterCallback(me);
162 }
163 }
164
165 void Body::newtonTriggerInsideCallback(NewtonBody* const visitor)
166 {
167 OgreNewt::Body* me = static_cast<OgreNewt::Body*>(NewtonBodyGetUserData(visitor));
168 if (me)
169 {
170 if (m_triggerInsideCallback)
171 m_triggerInsideCallback(me);
172 }
173 }
174
175 void Body::newtonTriggerExitCallback(NewtonBody* const visitor)
176 {
177 OgreNewt::Body* me = static_cast<OgreNewt::Body*>(NewtonBodyGetUserData(visitor));
178 if (me)
179 {
180 if (m_triggerExitCallback)
181 m_triggerExitCallback(me);
182 }
183 }
184
185
186 void _CDECL Body::newtonForceTorqueCallback(const NewtonBody* body, dFloat timeStep, int threadIndex)
187 {
188 OgreNewt::Body* me = static_cast<OgreNewt::Body*>(NewtonBodyGetUserData(body));
189 if (me)
190 {
191 if (me->m_forcecallback)
192 me->m_forcecallback(me, Ogre::Real(timeStep), threadIndex);
193 }
194 }
195
196 void Body::standardForceCallback(OgreNewt::Body* me, dFloat timestep, int threadIndex)
197 {
198 if (me)
199 {
200 //apply a simple gravity force.
201 Ogre::Real mass;
202 Ogre::Vector3 inertia;
203
204 me->getMassMatrix(mass, inertia);
205 Ogre::Vector3 gravityAcceleration(0.0f, -9.8f, 0.0f);
206 Ogre::Vector3 gravityForce = gravityAcceleration * mass;
207
208 me->addForce(gravityForce);
209
210 int nth = 0;
211
212 for (std::vector<std::pair<Ogre::Vector3, Ogre::Vector3> >::const_iterator it = me->m_accumulatedGlobalForces.begin(); it != me->m_accumulatedGlobalForces.end(); it++)
213 {
214 Ogre::LogManager::getSingleton().getDefaultLog()->logMessage("# [" + Ogre::StringConverter::toString(++nth) + "] force " + Ogre::StringConverter::toString(it->first) + " at " + Ogre::StringConverter::toString(it->second) + " to " + me->getOgreNode()->getName());
215
216 me->addGlobalForce(it->first, it->second);
217 }
218
219 me->m_accumulatedGlobalForces.clear();
220 }
221 }
222
223 // attachToNode
224 void Body::attachNode(Ogre::Node* node)
225 {
226 m_node = node;
227 node->_update(false, true);
228 updateNode(1.0f);
229 }
230
231 void Body::enableSimulation(bool state)
232 {
233 if (m_body)
234 {
235 if (state)
236 {
237 //NewtonBodyEnableSimulation(m_body);
238 unFreeze();
239 }
240 else
241 {
242 //NewtonBodyDisableSimulation(m_body); // this destroy joints
243 freeze();
244 }
245 }
246 }
247
248 void Body::setPositionOrientation(const Ogre::Vector3& pos, const Ogre::Quaternion& orient, int threadIndex)
249 {
250 if (m_body)
251 {
252 dFloat matrix[16];
253
254 // reset the previews Position and rotation for this body
255 m_curPosit = pos;
256 m_prevPosit = pos;
257 m_curRotation = orient;
258 m_prevRotation = orient;
259
260 OgreNewt::Converters::QuatPosToMatrix(orient, pos, &matrix[0]);
261
262 m_world->waitForUpdateToFinish();
263 m_world->criticalSectionLock();
264 NewtonBodySetMatrix(m_body, &matrix[0]);
265 m_world->criticalSectionUnlock();
266 updateNode(1.0f);
267 }
268 }
269
270 void Body::updatePositionOrientation(const Ogre::Vector3& pos, const Ogre::Quaternion& orient, int threadIndex)
271 {
272 if (m_body)
273 {
274 dFloat matrix[16];
275
276 // reset the previews Position and rotation for this body
277 m_curPosit = pos;
278 m_prevPosit = pos;
279 m_curRotation = orient;
280 m_prevRotation = orient;
281
282 OgreNewt::Converters::QuatPosToMatrix(orient, pos, &matrix[0]);
283 m_world->waitForUpdateToFinish();
284 m_world->criticalSectionLock();
285 NewtonBodySetMatrix(m_body, &matrix[0]);
286 m_world->criticalSectionUnlock();
287 }
288 }
289
290 //$BB add : set body position from node without node update
291 void Body::setPositionOrientationFromNode(int threadIndex)
292 {
293 if (m_body && m_node)
294 {
295 dFloat matrix[16];
296
297 // reset the previews Position and rotation for this body
298 // updated before the function call
299 //m_node->_update(false, true);
300 m_curPosit = m_node->_getDerivedPosition();
301 m_curRotation = m_node->_getDerivedOrientation();
302 m_prevPosit = m_curPosit;
303 m_prevRotation = m_curRotation;
304
305 OgreNewt::Converters::QuatPosToMatrix(m_curRotation, m_curPosit, &matrix[0]);
306 m_world->waitForUpdateToFinish();
307 m_world->criticalSectionLock();
308 NewtonBodySetMatrix(m_body, &matrix[0]);
309 m_world->criticalSectionUnlock();
310 }
311 }
312
313 // set mass matrix
314 void Body::setMassMatrix(Ogre::Real mass, const Ogre::Vector3& inertia)
315 {
316 if (m_body)
317 {
318 m_world->waitForUpdateToFinish();
319 NewtonBodySetMassMatrix(m_body, (float)mass, (float)inertia.x, (float)inertia.y, (float)inertia.z);
320 }
321 }
322
323 void Body::setMass(Ogre::Real mass)
324 {
325 if (m_body)
326 {
327 m_world->waitForUpdateToFinish();
328 NewtonBodySetMassProperties(m_body, (float)mass, NewtonBodyGetCollision(m_body));
329 }
330 }
331
332 // basic gravity callback
333 void Body::setStandardForceCallback()
334 {
335 setCustomForceAndTorqueCallback(standardForceCallback);
336 }
337
338 // custom user force callback
339 void Body::setCustomForceAndTorqueCallback(ForceCallback callback)
340 {
341 if (!m_forcecallback)
342 {
343 m_forcecallback = callback;
344 NewtonBodySetForceAndTorqueCallback(m_body, newtonForceTorqueCallback);
345 }
346 else
347 {
348 m_forcecallback = callback;
349 }
350 }
351
356
361
366
367 /*
368 // custom user force callback
369 void Body::setCustomTransformCallback( TransformCallback callback )
370 {
371 if (!m_transformcallback)
372 {
373 m_transformcallback = callback;
374 NewtonBodySetTransformCallback( m_body, newtonTransformCallback );
375 }
376 else
377 {
378 m_transformcallback = callback;
379 }
380 }
381 */
382
383 //set collision
384 void Body::setCollision(const OgreNewt::CollisionPtr& col)
385 {
386 m_collision = col;
387 m_world->waitForUpdateToFinish();
388 NewtonBodySetCollision(m_body, col->getNewtonCollision());
389 NewtonBodySetMassProperties(m_body, (float)0.0f, NewtonBodyGetCollision(m_body));
390 }
391
392 //get collision
393 const OgreNewt::CollisionPtr& Body::getCollision() const
394 {
395 return m_collision;
396 }
397
398 //get material group ID
399 const OgreNewt::MaterialID* Body::getMaterialGroupID() const
400 {
401 if (m_matid)
402 return m_matid;
403 else
404 return m_world->getDefaultMaterialID();
405 }
406
407 void Body::setScale(const Ogre::Vector3& scale, const Ogre::Quaternion& orient, Ogre::Vector3& pos)
408 {
409 if (m_scale == scale)
410 return;
411
412 dFloat matrix[16];
413 m_scale = scale;
414 NewtonCollision* collision = NewtonBodyGetCollision(m_body);
415 OgreNewt::Converters::QuatPosToMatrix(orient, pos, &matrix[0]);
416
417 m_world->waitForUpdateToFinish();
418 m_world->criticalSectionLock();
419 NewtonCollisionSetMatrix(collision, matrix);
420 NewtonBodySetCollisionScale(m_body, m_scale.x, m_scale.y, m_scale.z);
421 m_world->criticalSectionUnlock();
422 }
423
424 // get position and orientation
425 void Body::getPositionOrientation(Ogre::Vector3& pos, Ogre::Quaternion& orient) const
426 {
427 // Ogre::Real matrix[16];
428 // NewtonBodyGetMatrix ( m_body, matrix );
429 // NewtonBodyGetRotation ( m_body, &orient.w );
430 // pos = Ogre::Vector3( matrix[12], matrix[13], matrix[14] );
431
432 pos = m_curPosit;
433 orient = m_curRotation;
434 }
435
436 Ogre::Vector3 Body::getPosition() const
437 {
438 return m_curPosit;
439 }
440
441
442 Ogre::Quaternion Body::getOrientation() const
443 {
444 return m_curRotation;
445 }
446
448 void Body::getVisualPositionOrientation(Ogre::Vector3& pos, Ogre::Quaternion& orient) const
449 {
450 pos = m_nodePosit;
451 orient = m_nodeRotation;
452 }
453
454 Ogre::Vector3 Body::getVisualPosition() const
455 {
456 return m_nodePosit;
457 }
458
459
460 Ogre::Quaternion Body::getVisualOrientation() const
461 {
462 return m_nodeRotation;
463 }
464
465 Ogre::AxisAlignedBox Body::getAABB() const
466 {
467 Ogre::AxisAlignedBox ret;
468 dVector min, max;
469
470 NewtonBodyGetAABB(m_body, &min.m_x, &max.m_x);
471
472 Ogre::Vector3 dmin;
473 Ogre::Vector3 dmax;
474
475 dmin.x = Ogre::Real(min.m_x);
476 dmin.y = Ogre::Real(min.m_y);
477 dmin.z = Ogre::Real(min.m_z);
478
479 dmax.x = Ogre::Real(max.m_x);
480 dmax.y = Ogre::Real(max.m_y);
481 dmax.z = Ogre::Real(max.m_z);
482
483 ret.setExtents(dmin, dmax);
484 return ret;
485 }
486
487 void Body::getMassMatrix(Ogre::Real& mass, Ogre::Vector3& inertia) const
488 {
489 dFloat fMass;
490 dVector fInertia;
491 NewtonBodyGetMassMatrix(m_body, &fMass, &fInertia.m_x, &fInertia.m_y, &fInertia.m_z);
492
493 mass = Ogre::Real(fMass);
494 inertia.x = Ogre::Real(fInertia.m_x);
495 inertia.y = Ogre::Real(fInertia.m_y);
496 inertia.z = Ogre::Real(fInertia.m_z);
497 }
498
499 Ogre::Real Body::getMass() const
500 {
501 dFloat fMass;
502 dVector fInertia;
503 NewtonBodyGetMassMatrix(m_body, &fMass, &fInertia.m_x, &fInertia.m_y, &fInertia.m_z);
504
505 return Ogre::Real(fMass);
506 }
507
508 Ogre::Vector3 Body::getInertia() const
509 {
510 dFloat fMass;
511 dVector fInertia;
512 Ogre::Vector3 inertia;
513 NewtonBodyGetMassMatrix(m_body, &fMass, &fInertia.m_x, &fInertia.m_y, &fInertia.m_z);
514
515 inertia.x = Ogre::Real(fInertia.m_x);
516 inertia.y = Ogre::Real(fInertia.m_y);
517 inertia.z = Ogre::Real(fInertia.m_z);
518 return inertia;
519 }
520
521 void Body::getInvMass(Ogre::Real& mass, Ogre::Vector3& inertia) const
522 {
523 dFloat fMass;
524 dVector fInertia;
525 NewtonBodyGetInvMass(m_body, &fMass, &fInertia.m_x, &fInertia.m_y, &fInertia.m_z);
526
527 mass = Ogre::Real(fMass);
528 inertia.x = Ogre::Real(fInertia.m_x);
529 inertia.y = Ogre::Real(fInertia.m_y);
530 inertia.z = Ogre::Real(fInertia.m_z);
531 }
532
533 Ogre::Vector3 Body::getOmega() const
534 {
535 //m_world->waitForUpdateToFinish();
536 Ogre::Vector3 ret = Ogre::Vector3::ZERO;
537 dVector fVec;
538 NewtonBodyGetOmega(m_body, &fVec.m_x);
539 if (!_isnan(ret.x))
540 ret.x = Ogre::Real(fVec.m_x);
541 if (!_isnan(ret.y))
542 ret.y = Ogre::Real(fVec.m_y);
543 if (!_isnan(ret.z))
544 ret.z = Ogre::Real(fVec.m_z);
545 return ret;
546 }
547
548 Ogre::Vector3 Body::getVelocity() const
549 {
550 //m_world->waitForUpdateToFinish();
551 Ogre::Vector3 ret = Ogre::Vector3::ZERO;
552 dVector fVec;
553 NewtonBodyGetVelocity(m_body, &fVec.m_x);
554 if (!_isnan(ret.x))
555 ret.x = Ogre::Real(fVec.m_x);
556 if (!_isnan(ret.y))
557 ret.y = Ogre::Real(fVec.m_y);
558 if (!_isnan(ret.z))
559 ret.z = Ogre::Real(fVec.m_z);
560 return ret;
561 }
562
563 Ogre::Vector3 Body::getForce() const
564 {
565 //m_world->waitForUpdateToFinish();
566 Ogre::Vector3 ret = Ogre::Vector3::ZERO;
567 dVector fVec;
568 NewtonBodyGetForce(m_body, &fVec.m_x);
569 if (!_isnan(ret.x))
570 ret.x = Ogre::Real(fVec.m_x);
571 if (!_isnan(ret.y))
572 ret.y = Ogre::Real(fVec.m_y);
573 if (!_isnan(ret.z))
574 ret.z = Ogre::Real(fVec.m_z);
575 return ret;
576 }
577
578 Ogre::Vector3 Body::getTorque() const
579 {
580 //m_world->waitForUpdateToFinish();
581 Ogre::Vector3 ret = Ogre::Vector3::ZERO;
582 dVector fVec;
583 NewtonBodyGetTorque(m_body, &fVec.m_x);
584 if (!_isnan(ret.x))
585 ret.x = Ogre::Real(fVec.m_x);
586 if (!_isnan(ret.y))
587 ret.y = Ogre::Real(fVec.m_y);
588 if (!_isnan(ret.z))
589 ret.z = Ogre::Real(fVec.m_z);
590 return ret;
591 }
592
593 Ogre::Vector3 Body::getForceAcceleration() const
594 {
595 //m_world->waitForUpdateToFinish();
596 Ogre::Vector3 ret = Ogre::Vector3::ZERO;
597 dVector fVec;
598 NewtonBodyGetForceAcc(m_body, &fVec.m_x);
599 if (!_isnan(ret.x))
600 ret.x = Ogre::Real(fVec.m_x);
601 if (!_isnan(ret.y))
602 ret.y = Ogre::Real(fVec.m_y);
603 if (!_isnan(ret.z))
604 ret.z = Ogre::Real(fVec.m_z);
605 return ret;
606 }
607
608 Ogre::Vector3 Body::getTorqueAcceleration() const
609 {
610 //m_world->waitForUpdateToFinish();
611 Ogre::Vector3 ret = Ogre::Vector3::ZERO;
612 dVector fVec;
613 NewtonBodyGetTorqueAcc(m_body, &fVec.m_x);
614 if (!_isnan(ret.x))
615 ret.x = Ogre::Real(fVec.m_x);
616 if (!_isnan(ret.y))
617 ret.y = Ogre::Real(fVec.m_y);
618 if (!_isnan(ret.z))
619 ret.z = Ogre::Real(fVec.m_z);
620 return ret;
621 }
622
623 Ogre::Vector3 Body::calculateInverseDynamicsForce(Ogre::Real timestep, Ogre::Vector3 desiredVelocity)
624 {
625 Ogre::Vector3 ret = Ogre::Vector3::ZERO;
626 dVector fVec;
627 dVector fVel;
628 fVel.m_x = dFloat(desiredVelocity.x);
629 fVel.m_y = dFloat(desiredVelocity.y);
630 fVel.m_z = dFloat(desiredVelocity.z);
631
632 NewtonBodyCalculateInverseDynamicsForce(m_body, dFloat(timestep), &fVel.m_x, &fVec.m_x);
633 if (!_isnan(ret.x))
634 ret.x = Ogre::Real(fVec.m_x);
635 if (!_isnan(ret.y))
636 ret.y = Ogre::Real(fVec.m_y);
637 if (!_isnan(ret.z))
638 ret.z = Ogre::Real(fVec.m_z);
639 return ret;
640 }
641
642
643 Ogre::Vector3 Body::getAngularDamping() const
644 {
645 Ogre::Vector3 ret = Ogre::Vector3::ZERO;
646 dVector fVec;
647 NewtonBodyGetAngularDamping(m_body, &fVec.m_x);
648 if (!_isnan(ret.x))
649 ret.x = Ogre::Real(fVec.m_x);
650 if (!_isnan(ret.y))
651 ret.y = Ogre::Real(fVec.m_y);
652 if (!_isnan(ret.z))
653 ret.z = Ogre::Real(fVec.m_z);
654 return ret;
655 }
656
657 Ogre::Vector3 Body::getCenterOfMass() const
658 {
659 Ogre::Vector3 ret = Ogre::Vector3::ZERO;
660 dVector fVec;
661 NewtonBodyGetCentreOfMass(m_body, &fVec.m_x);
662 if (!_isnan(ret.x))
663 ret.x = Ogre::Real(fVec.m_x);
664 if (!_isnan(ret.y))
665 ret.y = Ogre::Real(fVec.m_y);
666 if (!_isnan(ret.z))
667 ret.z = Ogre::Real(fVec.m_z);
668 return ret;
669 }
670
671 Ogre::Vector3 Body::calculateOffset() const
672 {
673 Ogre::Vector3 offset = Ogre::Vector3::ZERO;
674 dVector fIner;
675 dVector fOff;
676
677 if (m_body)
678 {
679 NewtonConvexCollisionCalculateInertialMatrix(NewtonBodyGetCollision(m_body), &fIner.m_x, &fOff.m_x);
680
681 offset.x = Ogre::Real(fOff.m_x);
682 offset.y = Ogre::Real(fOff.m_y);
683 offset.z = Ogre::Real(fOff.m_z);
684 }
685
686 return offset;
687 }
688
689 Ogre::Vector3 Body::calculateInertialMatrix() const
690 {
691 Ogre::Vector3 inertia = Ogre::Vector3::ZERO;
692 dVector fIner;
693 dVector fOff;
694
695 if (m_body)
696 {
697 NewtonConvexCollisionCalculateInertialMatrix(NewtonBodyGetCollision(m_body), &fIner.m_x, &fOff.m_x);
698
699 inertia.x = Ogre::Real(fIner.m_x);
700 inertia.y = Ogre::Real(fIner.m_y);
701 inertia.z = Ogre::Real(fIner.m_z);
702 }
703
704 return inertia;
705 }
706
707 void Body::addGlobalForce(const Ogre::Vector3& force, const Ogre::Vector3& pos)
708 {
709 Ogre::Vector3 bodypos;
710 Ogre::Quaternion bodyorient;
711 getPositionOrientation(bodypos, bodyorient);
712
713 Ogre::Vector3 localMassCenter = getCenterOfMass();
714 Ogre::Vector3 globalMassCenter = bodypos + bodyorient * localMassCenter;
715
716 Ogre::Vector3 topoint = pos - globalMassCenter;
717 Ogre::Vector3 torque = topoint.crossProduct(force);
718
719 addForce(force);
720 addTorque(torque);
721 }
722
723 void Body::addGlobalForceAccumulate(const Ogre::Vector3& force, const Ogre::Vector3& pos)
724 {
725 m_accumulatedGlobalForces.push_back(std::pair<Ogre::Vector3, Ogre::Vector3>(force, pos));
726 }
727
728 void Body::addLocalForce(const Ogre::Vector3& force, const Ogre::Vector3& pos)
729 {
730 Ogre::Vector3 bodypos;
731 Ogre::Quaternion bodyorient;
732
733 getPositionOrientation(bodypos, bodyorient);
734
735 Ogre::Vector3 globalforce = bodyorient * force;
736 Ogre::Vector3 globalpoint = (bodyorient * pos) + bodypos;
737
738 addGlobalForce(globalforce, globalpoint);
739 }
740
741 Body* Body::getNext() const
742 {
743 NewtonBody* body = NewtonWorldGetNextBody(m_world->getNewtonWorld(), m_body);
744 if (body)
745 return (Body*)NewtonBodyGetUserData(body);
746
747 return NULL;
748 }
749
754
759
760 void Body::setVisualPosition(Ogre::Vector3 pos, Ogre::Quaternion quat)
761 {
762 m_nodePosit = pos;
763 m_nodeRotation = quat;
764 }
765
766 void Body::updateNode(Ogre::Real interpolatParam)
767 {
768 Ogre::Vector3 velocity = m_curPosit - m_prevPosit;
769
770 m_nodePosit = m_prevPosit + velocity * interpolatParam;
771 m_nodeRotation = Ogre::Quaternion::Slerp(interpolatParam, m_prevRotation, m_curRotation);
772
773 if (m_node)
774 {
775 //DO all in SBody callback!
776
777 // Set position in global terms.
778 /*Ogre::Node* m_nodeParent = m_node->getParent();
779 if (m_nodeParent)
780 {
781 //$BB add : force update to be sure of the derivated values
782 m_nodeParent->_update(false, true);
783
784 Ogre::Vector3 gscale = m_nodeParent->_getDerivedScale();
785 //if this is a bad scale we ignore the set position
786 if (gscale.x == 0.0f || gscale.y == 0.0f || gscale.z == 0.0f)
787 return;
788
789 Ogre::Vector3 invgscale = Ogre::Vector3::UNIT_SCALE / gscale;
790 m_node->setPosition((m_nodeParent->_getDerivedOrientation().Inverse() * (m_nodePosit - m_nodeParent->_getDerivedPosition()) * invgscale));
791 m_node->setOrientation((m_nodeParent->_getDerivedOrientation().Inverse() * m_nodeRotation));
792 }
793 else
794 {
795 m_node->setPosition(m_nodePosit);
796 m_node->setOrientation(m_nodeRotation);
797 }*/
798
799 if (m_nodeupdatenotifycallback)
800 m_nodeupdatenotifycallback(this);
801
802 if (m_nodeupdatejointnotifycallback)
803 m_nodeupdatejointnotifycallback(this);
804 }
805 }
806
807 void Body::setVelocity(const Ogre::Vector3& vel)
808 {
809 //m_world->waitForUpdateToFinish();
810 //NewtonWorldConvexCast(m_world,
811 dVector fVel;
812 fVel.m_x = dFloat(vel.x);
813 fVel.m_y = dFloat(vel.y);
814 fVel.m_z = dFloat(vel.z);
815
816 NewtonBodySetVelocity(m_body, &fVel.m_x);
817 }
818
819 // works only in physic listener
820 void Body::MoveToPosition(const Ogre::Vector3 &destPos, const Ogre::Real &stiffness, Ogre::Real timestep)
821 {
822 /*
823 fun getForce(hvec, gvec, vmass, vmassmat, vnbsec, nbframes)=
824 let (divideVectorF (subVectorF hvec gvec) vnbsec) -> vel in
825 let multiplyVectorF (divideVectorF vel vnbsec) vmass -> hforce in
826 [hforce vel];;
827 */
828
829 dMatrix matrix;
830 dVector veloc0;
831 dVector targetPositionInGlobalSpace(destPos.x, destPos.y, destPos.z, 0.0f);
832
833 dFloat invTimeStep = (timestep > 0.0f) ? 1.0f / timestep : 1.0f;
834 NewtonWorld* const world = NewtonBodyGetWorld(m_body);
835 if (!world)
836 return;
837 NewtonWorldCriticalSectionLock(world, 0);
838
839 // calculate the desired impulse
840 NewtonBodyGetMatrix(m_body, &matrix[0][0]);
841 NewtonBodyGetVelocity(m_body, &veloc0[0]);
842
843 dVector deltaVeloc(targetPositionInGlobalSpace - matrix.m_posit);
844 deltaVeloc = deltaVeloc.Scale(stiffness * invTimeStep);
845
846 // convert the delta velocity change to a external force and torque
847 dFloat Ixx;
848 dFloat Iyy;
849 dFloat Izz;
850 dFloat mass;
851 NewtonBodyGetMassMatrix(m_body, &mass, &Ixx, &Iyy, &Izz);
852 dVector force((deltaVeloc - veloc0).Scale(mass * invTimeStep));
853
854 NewtonBodyAddForce(m_body, &force[0]);
855 NewtonBodySetSleepState(m_body, 0);
856
857 NewtonWorldCriticalSectionUnlock(world);
858 }
859
860 void Body::RotateToOrientation(const Ogre::Quaternion &destquat, const Ogre::Real &stiffness, Ogre::Real timestep)
861 {
862 dMatrix matrix;
863 dVector omega0;
864 dVector fRot;
865
866
867 dFloat invTimeStep = (timestep > 0.0f) ? 1.0f / timestep : 1.0f;
868 NewtonWorld* const world = NewtonBodyGetWorld(m_body);
869 if (!world)
870 return;
871
872 NewtonWorldCriticalSectionLock(world, 0);
873
874 // calculate the desired impulse
875 NewtonBodyGetMatrix(m_body, &matrix[0][0]);
876 NewtonBodyGetOmega(m_body, &omega0[0]);
877 NewtonBodyGetRotation(m_body, &fRot.m_x);
878
879 // convert the delta velocity change to a external force and torque
880 dFloat Ixx;
881 dFloat Iyy;
882 dFloat Izz;
883 dFloat mass;
884 NewtonBodyGetMassMatrix(m_body, &mass, &Ixx, &Iyy, &Izz);
885 dVector angularMomentum(Ixx, Iyy, Izz);
886
887 Ogre::Quaternion rot(Ogre::Real(fRot.m_x), Ogre::Real(fRot.m_y), Ogre::Real(fRot.m_z), Ogre::Real(fRot.m_w));
888 Ogre::Quaternion diffq = destquat * rot.Inverse();
889 Ogre::Euler euler(diffq);
890 dVector domega(euler.getPitch().valueRadians(), euler.getYaw().valueRadians(), euler.getRoll().valueRadians());
891 domega = domega.Scale(invTimeStep);
892 domega = domega - omega0;
893 //multiplyVectorF (divideVectorF omega vnbsec) vmassmat
894
895 angularMomentum = matrix.RotateVector(angularMomentum.CompProduct(matrix.UnrotateVector(domega)));
896 dVector torque(angularMomentum.Scale(invTimeStep * stiffness));
897
898 NewtonBodyAddTorque(m_body, &torque[0]);
899
900 NewtonBodySetSleepState(m_body, 0);
901 NewtonWorldCriticalSectionUnlock(world);
902 }
903
904 // --------------------------------------------------------------------------------------
905
906
907}
OgreNewt_Body.h
OgreNewt_Collision.h
OgreNewt_Stdafx.h
OgreNewt_Tools.h
OgreNewt_World.h
Ogre::Euler
Class for Euler rotations.
Definition SO3Euler.h:25
Ogre::Euler::getYaw
Ogre::Radian getYaw() const
Get the Yaw angle.
Definition SO3Euler.h:70
Ogre::Euler::getRoll
Ogre::Radian getRoll() const
Get the Roll angle.
Definition SO3Euler.h:76
Ogre::Euler::getPitch
Ogre::Radian getPitch() const
Get the Pitch angle.
Definition SO3Euler.h:73
OgreNewt::Body
main class for all Rigid Bodies in the system.
Definition OgreNewt_Body.h:39
OgreNewt::Body::MoveToPosition
void MoveToPosition(const Ogre::Vector3 &destPos, const Ogre::Real &stiffness, Ogre::Real timestep)
Definition OgreNewt_Body.cpp:820
OgreNewt::Body::updatePositionOrientation
void updatePositionOrientation(const Ogre::Vector3 &pos, const Ogre::Quaternion &orient, int threadIndex=-1)
Definition OgreNewt_Body.cpp:270
OgreNewt::Body::getMassMatrix
void getMassMatrix(Ogre::Real &mass, Ogre::Vector3 &inertia) const
get Ogre::Real(mass) and Ogre::Vector3(inertia) of the body.
Definition OgreNewt_Body.cpp:487
OgreNewt::Body::getMass
Ogre::Real getMass() const
return body mass
Definition OgreNewt_Body.cpp:499
OgreNewt::Body::enableSimulation
void enableSimulation(bool state)
Definition OgreNewt_Body.cpp:231
OgreNewt::Body::getCollision
const OgreNewt::CollisionPtr & getCollision() const
set the factors that cause a body to "freeze" when equilibrium reached.
Definition OgreNewt_Body.cpp:393
OgreNewt::Body::m_nodePosit
Ogre::Vector3 m_nodePosit
Definition OgreNewt_Body.h:633
OgreNewt::Body::setScale
void setScale(const Ogre::Vector3 &scale, const Ogre::Quaternion &orient, Ogre::Vector3 &pos)
set the collision scale
Definition OgreNewt_Body.cpp:407
OgreNewt::Body::setCustomForceAndTorqueCallback
void setCustomForceAndTorqueCallback(ForceCallback callback)
set a custom force callback for this body to use.
Definition OgreNewt_Body.cpp:339
OgreNewt::Body::getOrientation
Ogre::Quaternion getOrientation() const
returns body orientation
Definition OgreNewt_Body.cpp:442
OgreNewt::Body::m_userdata
Ogre::Any m_userdata
Definition OgreNewt_Body.h:643
OgreNewt::Body::setTriggerExitCallback
void setTriggerExitCallback(TriggerExitCallback callback)
Definition OgreNewt_Body.cpp:362
OgreNewt::Body::addGlobalForceAccumulate
void addGlobalForceAccumulate(const Ogre::Vector3 &force, const Ogre::Vector3 &pos)
helper function that adds a force (and resulting torque) to an object in global cordinates called fro...
Definition OgreNewt_Body.cpp:723
OgreNewt::Body::getForce
Ogre::Vector3 getForce() const
get the force acting on the body.
Definition OgreNewt_Body.cpp:563
OgreNewt::Body::getInvMass
void getInvMass(Ogre::Real &mass, Ogre::Vector3 &inertia) const
get invert mass + inertia for the body.
Definition OgreNewt_Body.cpp:521
OgreNewt::Body::setTriggerEnterCallback
void setTriggerEnterCallback(TriggerEnterCallback callback)
Definition OgreNewt_Body.cpp:352
OgreNewt::Body::addLocalForce
void addLocalForce(const Ogre::Vector3 &force, const Ogre::Vector3 &pos)
Definition OgreNewt_Body.cpp:728
OgreNewt::Body::getVisualOrientation
Ogre::Quaternion getVisualOrientation() const
returns body visual orientation
Definition OgreNewt_Body.cpp:460
OgreNewt::Body::getMaterialGroupID
const OgreNewt::MaterialID * getMaterialGroupID() const
get a pointer to the Material assigned to this body.
Definition OgreNewt_Body.cpp:399
OgreNewt::Body::setNodeUpdateJointNotify
void setNodeUpdateJointNotify(NodeUpdateNotifyCallback callback)
Definition OgreNewt_Body.cpp:755
OgreNewt::Body::m_triggerInsideCallback
TriggerInsideCallback m_triggerInsideCallback
Definition OgreNewt_Body.h:654
OgreNewt::Body::setVisualPosition
void setVisualPosition(Ogre::Vector3 pos, Ogre::Quaternion quat)
Definition OgreNewt_Body.cpp:760
OgreNewt::Body::freeze
void freeze()
freeze the rigid body.
Definition OgreNewt_Body.h:295
OgreNewt::Body::addGlobalForce
void addGlobalForce(const Ogre::Vector3 &force, const Ogre::Vector3 &pos)
helper function that adds a force (and resulting torque) to an object in global cordinates.
Definition OgreNewt_Body.cpp:707
OgreNewt::Body::getVelocity
Ogre::Vector3 getVelocity() const
get velocity of the body. in global coordinates.
Definition OgreNewt_Body.cpp:548
OgreNewt::Body::getPosition
Ogre::Vector3 getPosition() const
returns body position
Definition OgreNewt_Body.cpp:436
OgreNewt::Body::TriggerEnterCallback
std::function< void(OgreNewt::Body *)> TriggerEnterCallback
Definition OgreNewt_Body.h:51
OgreNewt::Body::setStandardForceCallback
void setStandardForceCallback()
set a standard gravity callback for this body to use.
Definition OgreNewt_Body.cpp:333
OgreNewt::Body::m_forcecallback
ForceCallback m_forcecallback
Definition OgreNewt_Body.h:652
OgreNewt::Body::m_triggerEnterCallback
TriggerEnterCallback m_triggerEnterCallback
Definition OgreNewt_Body.h:653
OgreNewt::Body::m_scale
Ogre::Vector3 m_scale
Definition OgreNewt_Body.h:636
OgreNewt::Body::m_prevPosit
Ogre::Vector3 m_prevPosit
Definition OgreNewt_Body.h:635
OgreNewt::Body::updateNode
void updateNode(Ogre::Real interpolatParam)
update the position of the node (if attached) and sets m_nodeupdateneeded to false
Definition OgreNewt_Body.cpp:766
OgreNewt::Body::addTorque
void addTorque(const Ogre::Vector3 &torque)
add torque to the body.
Definition OgreNewt_Body.h:519
OgreNewt::Body::TriggerExitCallback
std::function< void(OgreNewt::Body *)> TriggerExitCallback
Definition OgreNewt_Body.h:53
OgreNewt::Body::setMassMatrix
void setMassMatrix(Ogre::Real mass, const Ogre::Vector3 &inertia)
set the mass and inertia for the body.
Definition OgreNewt_Body.cpp:314
OgreNewt::Body::addForce
void addForce(const Ogre::Vector3 &force)
add force to the body.
Definition OgreNewt_Body.h:505
OgreNewt::Body::getNext
Body * getNext() const
use this function to iterate through all bodies
Definition OgreNewt_Body.cpp:741
OgreNewt::Body::m_body
NewtonBody * m_body
Definition OgreNewt_Body.h:627
OgreNewt::Body::m_nodeupdatejointnotifycallback
NodeUpdateNotifyCallback m_nodeupdatejointnotifycallback
Definition OgreNewt_Body.h:658
OgreNewt::Body::m_node
Ogre::Node * m_node
Definition OgreNewt_Body.h:649
OgreNewt::Body::getVisualPosition
Ogre::Vector3 getVisualPosition() const
return body visual position
Definition OgreNewt_Body.cpp:454
OgreNewt::Body::getCenterOfMass
Ogre::Vector3 getCenterOfMass() const
get the center of mass.
Definition OgreNewt_Body.cpp:657
OgreNewt::Body::getOmega
Ogre::Vector3 getOmega() const
get omega of the body. in global space.
Definition OgreNewt_Body.cpp:533
OgreNewt::Body::NodeUpdateNotifyCallback
std::function< void(OgreNewt::Body *)> NodeUpdateNotifyCallback
node update notify.
Definition OgreNewt_Body.h:65
OgreNewt::Body::m_curRotation
Ogre::Quaternion m_curRotation
Definition OgreNewt_Body.h:638
OgreNewt::Body::ForceCallback
std::function< void(OgreNewt::Body *, Ogre::Real timeStep, int threadIndex)> ForceCallback
custom force callback.
Definition OgreNewt_Body.h:49
OgreNewt::Body::m_accumulatedGlobalForces
std::vector< std::pair< Ogre::Vector3, Ogre::Vector3 > > m_accumulatedGlobalForces
Definition OgreNewt_Body.h:632
OgreNewt::Body::setPositionOrientationFromNode
void setPositionOrientationFromNode(int threadIndex=-1)
position and orient the body from node.
Definition OgreNewt_Body.cpp:291
OgreNewt::Body::setMass
void setMass(Ogre::Real mass)
Definition OgreNewt_Body.cpp:323
OgreNewt::Body::calculateInverseDynamicsForce
Ogre::Vector3 calculateInverseDynamicsForce(Ogre::Real timestep, Ogre::Vector3 desiredVelocity)
calculate force needed for given velocity
Definition OgreNewt_Body.cpp:623
OgreNewt::Body::calculateOffset
Ogre::Vector3 calculateOffset() const
Definition OgreNewt_Body.cpp:671
OgreNewt::Body::m_world
World *const m_world
Definition OgreNewt_Body.h:630
OgreNewt::Body::Body
Body(World *const W, const OgreNewt::CollisionPtr &col, int bodytype=0, bool trigger=false)
constructor.
Definition OgreNewt_Body.cpp:13
OgreNewt::Body::m_type
int m_type
Definition OgreNewt_Body.h:648
OgreNewt::Body::setPositionOrientation
void setPositionOrientation(const Ogre::Vector3 &pos, const Ogre::Quaternion &orient, int threadIndex=-1)
position and orient the body arbitrarily.
Definition OgreNewt_Body.cpp:248
OgreNewt::Body::getInertia
Ogre::Vector3 getInertia() const
return body inertia
Definition OgreNewt_Body.cpp:508
OgreNewt::Body::attachNode
void attachNode(Ogre::Node *node)
attach this body to an Ogre::Node*
Definition OgreNewt_Body.cpp:224
OgreNewt::Body::~Body
~Body()
destructor
Definition OgreNewt_Body.cpp:72
OgreNewt::Body::m_matid
const MaterialID * m_matid
Definition OgreNewt_Body.h:629
OgreNewt::Body::m_triggerExitCallback
TriggerExitCallback m_triggerExitCallback
Definition OgreNewt_Body.h:655
OgreNewt::Body::getForceAcceleration
Ogre::Vector3 getForceAcceleration() const
get the linear acceleration due to forces acting on the body.
Definition OgreNewt_Body.cpp:593
OgreNewt::Body::m_nodeupdatenotifycallback
NodeUpdateNotifyCallback m_nodeupdatenotifycallback
Definition OgreNewt_Body.h:657
OgreNewt::Body::m_curPosit
Ogre::Vector3 m_curPosit
Definition OgreNewt_Body.h:634
OgreNewt::Body::setNodeUpdateNotify
void setNodeUpdateNotify(NodeUpdateNotifyCallback callback)
set a custom node update notify.
Definition OgreNewt_Body.cpp:750
OgreNewt::Body::getAABB
Ogre::AxisAlignedBox getAABB() const
get the axis-aligned bounding box for this body.
Definition OgreNewt_Body.cpp:465
OgreNewt::Body::getOgreNode
Ogre::Node * getOgreNode() const
get a pointer to the attached Node.
Definition OgreNewt_Body.h:133
OgreNewt::Body::setVelocity
void setVelocity(const Ogre::Vector3 &vel)
set an arbitrary velocity for the body.
Definition OgreNewt_Body.cpp:807
OgreNewt::Body::calculateInertialMatrix
Ogre::Vector3 calculateInertialMatrix() const
Definition OgreNewt_Body.cpp:689
OgreNewt::Body::getTorqueAcceleration
Ogre::Vector3 getTorqueAcceleration() const
get the rotational acceleration due to torque acting on the body.
Definition OgreNewt_Body.cpp:608
OgreNewt::Body::RotateToOrientation
void RotateToOrientation(const Ogre::Quaternion &destquat, const Ogre::Real &stiffness, Ogre::Real timestep)
Definition OgreNewt_Body.cpp:860
OgreNewt::Body::getVisualPositionOrientation
void getVisualPositionOrientation(Ogre::Vector3 &pos, Ogre::Quaternion &orient) const
get the node position and orientation in form of an Ogre::Vector(position) and Ogre::Quaternion(orien...
Definition OgreNewt_Body.cpp:448
OgreNewt::Body::getAngularDamping
Ogre::Vector3 getAngularDamping() const
get angular damping
Definition OgreNewt_Body.cpp:643
OgreNewt::Body::m_collision
OgreNewt::CollisionPtr m_collision
Definition OgreNewt_Body.h:628
OgreNewt::Body::getTorque
Ogre::Vector3 getTorque() const
get the torque acting on the body.
Definition OgreNewt_Body.cpp:578
OgreNewt::Body::setCollision
void setCollision(const OgreNewt::CollisionPtr &col)
set the collision that represents the shape of the body
Definition OgreNewt_Body.cpp:384
OgreNewt::Body::m_prevRotation
Ogre::Quaternion m_prevRotation
Definition OgreNewt_Body.h:639
OgreNewt::Body::TriggerInsideCallback
std::function< void(OgreNewt::Body *)> TriggerInsideCallback
Definition OgreNewt_Body.h:52
OgreNewt::Body::setTriggerInsideCallback
void setTriggerInsideCallback(TriggerInsideCallback callback)
Definition OgreNewt_Body.cpp:357
OgreNewt::Body::m_nodeRotation
Ogre::Quaternion m_nodeRotation
Definition OgreNewt_Body.h:637
OgreNewt::Body::getPositionOrientation
void getPositionOrientation(Ogre::Vector3 &pos, Ogre::Quaternion &orient) const
get position and orientation in form of an Ogre::Vector(position) and Ogre::Quaternion(orientation)
Definition OgreNewt_Body.cpp:425
OgreNewt::Body::unFreeze
void unFreeze()
unfreeze the rigid body.
Definition OgreNewt_Body.h:301
OgreNewt::Collision
represents a shape for collision detection
Definition OgreNewt_Collision.h:51
OgreNewt::Collision::getNewtonCollision
NewtonCollision *const getNewtonCollision() const
retrieve the Newton pointer
Definition OgreNewt_Collision.h:70
OgreNewt::MaterialID
represents a material
Definition OgreNewt_MaterialID.h:25
OgreNewt::World
represents a physics world.
Definition OgreNewt_World.h:142
OgreNewt::World::DestroyController
void DestroyController(CustomTriggerController *const controller)
Definition OgreNewt_World.cpp:90
OgreNewt::World::criticalSectionUnlock
void criticalSectionUnlock() const
notify the exit of a critical section of code.
Definition OgreNewt_World.h:359
OgreNewt::World::getDefaultMaterialID
const MaterialID * getDefaultMaterialID() const
get the default materialID object.
Definition OgreNewt_World.h:291
OgreNewt::World::getNewtonWorld
NewtonWorld * getNewtonWorld() const
retrieves a pointer to the NewtonWorld
Definition OgreNewt_World.h:284
OgreNewt::World::criticalSectionLock
void criticalSectionLock() const
notify an entrance to a critical section of code.
Definition OgreNewt_World.h:356
OgreNewt::World::CreateController
CustomTriggerController * CreateController(const dMatrix &matrix, NewtonCollision *const convexShape)
Definition OgreNewt_World.cpp:82
OgreNewt::World::waitForUpdateToFinish
void waitForUpdateToFinish() const
Definition OgreNewt_World.h:361
OgreNewt::WorldTriggerManager::TriggerCallback::setTriggerInsideCallback
void setTriggerInsideCallback(WorldTriggerInsideCallback callback)
Definition OgreNewt_World.cpp:22
OgreNewt::WorldTriggerManager::TriggerCallback::setTriggerExitCallback
void setTriggerExitCallback(WorldTriggerExitCallback callback)
Definition OgreNewt_World.cpp:27
OgreNewt::WorldTriggerManager::TriggerCallback::setTriggerEnterCallback
void setTriggerEnterCallback(WorldTriggerEnterCallback callback)
Definition OgreNewt_World.cpp:17
OgreNewt::Converters::QuatPosToMatrix
_OgreNewtExport void QuatPosToMatrix(const Ogre::Quaternion &quat, const Ogre::Vector3 &pos, dFloat *matrix)
Take a Quaternion and Position Matrix and create a Newton-happy float matrix!
Definition OgreNewt_Tools.cpp:33
Generated by doxygen 1.9.8