Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/presentationHS12/src/orxonox/worldentities/WorldEntity.cc @ 10155

Last change on this file since 10155 was 8858, checked in by landauf, 13 years ago

merged output branch back to trunk.

Changes:

  • you have to include util/Output.h instead of util/Debug.h
  • COUT(x) is now called orxout(level)
  • output levels are now defined by an enum instead of numbers. see util/Output.h for the definition
  • it's possible to use output contexts with orxout(level, context). see util/Output.h for some common contexts. you can define more contexts
  • you must use 'endl' at the end of an output message, '\n' does not flush the message

Output levels:

  • instead of COUT(0) use orxout()
  • instead of COUT(1) use orxout(user_error) or orxout(internal_error)
  • instead of COUT(2) use orxout(user_warning) or orxout(internal_warning)
  • instead of COUT(3) use orxout(user_status/user_info) or orxout(internal_status/internal_info)
  • instead of COUT(4) use orxout(verbose)
  • instead of COUT(5) use orxout(verbose_more)
  • instead of COUT(6) use orxout(verbose_ultra)

Guidelines:

  • user_* levels are for the user, visible in the console and the log-file
  • internal_* levels are for developers, visible in the log-file
  • verbose_* levels are for debugging, only visible if the context of the output is activated

Usage in C++:

  • orxout() << "message" << endl;
  • orxout(level) << "message" << endl;
  • orxout(level, context) << "message" << endl;

Usage in Lua:

  • orxout("message")
  • orxout(orxonox.level.levelname, "message")
  • orxout(orxonox.level.levelname, "context", "message")

Usage in Tcl (and in the in-game-console):

  • orxout levelname message
  • orxout_context levelname context message
  • shortcuts: log message, error message, warning message, status message, info message, debug message
  • Property svn:eol-style set to native
File size: 37.7 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *      Reto Grieder (physics)
25 *   Co-authors:
26 *      ...
27 *
28 */
29
30#include "WorldEntity.h"
31
32#include <OgreBillboardSet.h>
33#include <OgreCamera.h>
34#include <OgreEntity.h>
35#include <OgreParticleSystem.h>
36#include <OgreSceneManager.h>
37#include <OgreSceneNode.h>
38#include <BulletDynamics/Dynamics/btRigidBody.h>
39#include <boost/static_assert.hpp>
40
41#include "util/OrxAssert.h"
42#include "util/Convert.h"
43#include "util/Exception.h"
44#include "core/CoreIncludes.h"
45#include "core/XMLPort.h"
46#include "Scene.h"
47#include "collisionshapes/WorldEntityCollisionShape.h"
48
49namespace orxonox
50{
51    const Vector3 WorldEntity::FRONT = Vector3::NEGATIVE_UNIT_Z;
52    const Vector3 WorldEntity::BACK  = Vector3::UNIT_Z;
53    const Vector3 WorldEntity::LEFT  = Vector3::NEGATIVE_UNIT_X;
54    const Vector3 WorldEntity::RIGHT = Vector3::UNIT_X;
55    const Vector3 WorldEntity::DOWN  = Vector3::NEGATIVE_UNIT_Y;
56    const Vector3 WorldEntity::UP    = Vector3::UNIT_Y;
57
58    // Be sure we don't do bad conversions
59    BOOST_STATIC_ASSERT((int)Ogre::Node::TS_LOCAL  == (int)WorldEntity::Local);
60    BOOST_STATIC_ASSERT((int)Ogre::Node::TS_PARENT == (int)WorldEntity::Parent);
61    BOOST_STATIC_ASSERT((int)Ogre::Node::TS_WORLD  == (int)WorldEntity::World);
62
63    /**
64    @brief
65        Creates a new WorldEntity that may immediately be used.
66        All the default values are being set here.
67    */
68    WorldEntity::WorldEntity(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
69    {
70        RegisterObject(WorldEntity);
71
72        if (!this->getScene() || !this->getScene()->getRootSceneNode())
73            ThrowException(AbortLoading, "Can't create WorldEntity, no scene or no root-scenenode given.");
74
75        this->node_ = this->getScene()->getRootSceneNode()->createChildSceneNode();
76
77        this->parent_ = 0;
78        this->parentID_ = OBJECTID_UNKNOWN;
79        this->bDeleteWithParent_ = true;
80
81        this->node_->setPosition(Vector3::ZERO);
82        this->node_->setOrientation(Quaternion::IDENTITY);
83
84        // Activity and visibility memory.
85        this->bActiveMem_ = true;
86        this->bVisibleMem_ = true;
87
88
89        // Default behaviour does not include physics
90        this->physicalBody_   = 0;
91        this->bPhysicsActive_ = false;
92        this->bPhysicsActiveSynchronised_    = false;
93        this->bPhysicsActiveBeforeAttaching_ = false;
94        this->collisionShape_ = new WorldEntityCollisionShape(this);
95        this->collisionType_             = None;
96        this->collisionTypeSynchronised_ = None;
97        this->mass_           = 1.0f;
98        this->childrenMass_   = 0;
99        // Using bullet default values
100        this->restitution_    = 0;
101        this->angularFactor_  = 1;
102        this->linearDamping_  = 0;
103        this->angularDamping_ = 0;
104        this->friction_       = 0.5;
105        this->bCollisionCallbackActive_ = false;
106        this->bCollisionResponseActive_ = true;
107
108        this->registerVariables();
109    }
110
111    /**
112    @brief
113        Destroys the WorldEntity AND ALL its children with it.
114    */
115    WorldEntity::~WorldEntity()
116    {
117        if (this->isInitialized())
118        {
119            if (this->parent_)
120                this->detachFromParent();
121
122            std::set<WorldEntity*>::iterator it;
123            while ((it = this->children_.begin()) != this->children_.end())
124            {
125                WorldEntity* entity = *it;
126
127                // do this for all children, because even if getDeleteWithParent() returns true a child might still stay active due to smart pointers pointing to it
128                entity->setPosition(entity->getWorldPosition());
129                this->detach(entity); // detach also erases the element from the children set
130
131                if (entity->getDeleteWithParent())
132                    entity->destroy();
133            }
134
135            if (this->physicalBody_)
136            {
137                this->deactivatePhysics();
138                delete this->physicalBody_;
139            }
140            this->collisionShape_->destroy();
141
142            this->node_->detachAllObjects();
143            this->node_->removeAllChildren();
144
145            OrxAssert(this->getScene()->getSceneManager(), "No SceneManager defined in a WorldEntity.");
146            this->getScene()->getSceneManager()->destroySceneNode(this->node_->getName());
147        }
148    }
149
150    void WorldEntity::XMLPort(Element& xmlelement, XMLPort::Mode mode)
151    {
152        SUPER(WorldEntity, XMLPort, xmlelement, mode);
153
154        XMLPortParamTemplate(WorldEntity, "position",    setPosition,    getPosition,    xmlelement, mode, const Vector3&);
155        XMLPortParamTemplate(WorldEntity, "orientation", setOrientation, getOrientation, xmlelement, mode, const Quaternion&);
156        XMLPortParamTemplate(WorldEntity, "scale3D",     setScale3D,     getScale3D,     xmlelement, mode, const Vector3&);
157        XMLPortParam        (WorldEntity, "scale",       setScale,       getScale,       xmlelement, mode);
158        XMLPortParamLoadOnly(WorldEntity, "lookat",      lookAt_xmlport,       xmlelement, mode);
159        XMLPortParamLoadOnly(WorldEntity, "direction",   setDirection_xmlport, xmlelement, mode);
160        XMLPortParamLoadOnly(WorldEntity, "yaw",         yaw_xmlport,          xmlelement, mode);
161        XMLPortParamLoadOnly(WorldEntity, "pitch",       pitch_xmlport,        xmlelement, mode);
162        XMLPortParamLoadOnly(WorldEntity, "roll",        roll_xmlport,         xmlelement, mode);
163        XMLPortParam        (WorldEntity, "deletewithparent", setDeleteWithParent, getDeleteWithParent, xmlelement, mode);
164
165        // Physics
166        XMLPortParam(WorldEntity, "collisionType",     setCollisionTypeStr,  getCollisionTypeStr,  xmlelement, mode);
167        XMLPortParam(WorldEntity, "collisionResponse", setCollisionResponse, hasCollisionResponse, xmlelement, mode);
168        XMLPortParam(WorldEntity, "mass",              setMass,              getMass,              xmlelement, mode);
169        XMLPortParam(WorldEntity, "restitution",       setRestitution,       getRestitution,       xmlelement, mode);
170        XMLPortParam(WorldEntity, "angularFactor",     setAngularFactor,     getAngularFactor,     xmlelement, mode);
171        XMLPortParam(WorldEntity, "linearDamping",     setLinearDamping,     getLinearDamping,     xmlelement, mode);
172        XMLPortParam(WorldEntity, "angularDamping",    setAngularDamping,    getAngularDamping,    xmlelement, mode);
173        XMLPortParam(WorldEntity, "friction",          setFriction,          getFriction,          xmlelement, mode);
174
175        // Other attached WorldEntities
176        XMLPortObject(WorldEntity, WorldEntity, "attached", attach, getAttachedObject, xmlelement, mode);
177        // Attached collision shapes
178        XMLPortObject(WorldEntity, CollisionShape, "collisionShapes", attachCollisionShape, getAttachedCollisionShape, xmlelement, mode);
179    }
180
181    void WorldEntity::registerVariables()
182    {
183        registerVariable(this->mainStateName_,  VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedMainStateName));
184
185        registerVariable(this->bActive_,        VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedActivity));
186        registerVariable(this->bVisible_,       VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedVisibility));
187
188        registerVariable(this->getScale3D(),    VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::scaleChanged));
189
190        // Physics stuff
191        registerVariable(this->mass_,           VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::massChanged));
192        registerVariable(this->restitution_,    VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::restitutionChanged));
193        registerVariable(this->angularFactor_,  VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::angularFactorChanged));
194        registerVariable(this->linearDamping_,  VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::linearDampingChanged));
195        registerVariable(this->angularDamping_, VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::angularDampingChanged));
196        registerVariable(this->friction_,       VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::frictionChanged));
197        registerVariable(this->bCollisionCallbackActive_,
198                                                VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionCallbackActivityChanged));
199        registerVariable(this->bCollisionResponseActive_,
200                                                VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionResponseActivityChanged));
201        registerVariable((int&)this->collisionTypeSynchronised_,
202                                                VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionTypeChanged));
203        registerVariable(this->bPhysicsActiveSynchronised_,
204                                                VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::physicsActivityChanged));
205
206        // Attach to parent if necessary
207        registerVariable(this->parentID_,       VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::networkcallback_parentChanged));
208    }
209
210    /**
211    @brief
212        When the activity is changed, it is changed for all attached objects as well.
213    */
214    void WorldEntity::changedActivity(void)
215    {
216        SUPER(WorldEntity, changedActivity);
217
218        if(GameMode::isMaster())
219        {
220            for (std::set<WorldEntity*>::const_iterator it = this->getAttachedObjects().begin(); it != this->getAttachedObjects().end(); it++)
221            {
222                if(!this->isActive())
223                {
224                    (*it)->bActiveMem_ = (*it)->isActive();
225                    (*it)->setActive(this->isActive());
226                }
227                else
228                {
229                    (*it)->setActive((*it)->bActiveMem_);
230                }
231            }
232        }
233    }
234
235    /**
236    @brief
237        When the visibility is changed, it is changed for all attached objects as well.
238    */
239    void WorldEntity::changedVisibility(void)
240    {
241        SUPER(WorldEntity, changedVisibility);
242
243        if(GameMode::isMaster())
244        {
245            for (std::set<WorldEntity*>::const_iterator it = this->getAttachedObjects().begin(); it != this->getAttachedObjects().end(); it++)
246            {
247                if(!this->isVisible())
248                {
249                    (*it)->bVisibleMem_ = (*it)->isVisible();
250                    (*it)->setVisible(this->isVisible());
251                }
252                else
253                {
254                    (*it)->setVisible((*it)->bVisibleMem_);
255                }
256            }
257        }
258    }
259
260    /**
261    @brief
262        Network function that object this instance to its correct parent.
263    */
264    void WorldEntity::networkcallback_parentChanged()
265    {
266        if (this->parentID_ != OBJECTID_UNKNOWN)
267        {
268            WorldEntity* parent = orxonox_cast<WorldEntity*>(Synchronisable::getSynchronisable(this->parentID_));
269            if (parent)
270                this->attachToParent(parent);
271        }
272    }
273
274    /**
275    @brief
276        Attaches this object to a parent SceneNode.
277    @remarks
278        Only use this method if you know exactly what you're doing!
279        Normally, attaching works internally by attaching WE's.
280    */
281    void WorldEntity::attachToNode(Ogre::SceneNode* node)
282    {
283        Ogre::Node* parent = this->node_->getParent();
284        if (parent)
285            parent->removeChild(this->node_);
286        node->addChild(this->node_);
287    }
288
289    /**
290    @brief
291        Detaches this object from a parent SceneNode.
292    @remarks
293        Only use this method if you know exactly what you're doing!
294        Normally, attaching works internally by attaching WE's.
295    */
296    void WorldEntity::detachFromNode(Ogre::SceneNode* node)
297    {
298        node->removeChild(this->node_);
299//        this->getScene()->getRootSceneNode()->addChild(this->node_);
300    }
301
302    /**
303    @brief
304        Network callback for the collision type. Only change the type if it was valid.
305    */
306    void WorldEntity::collisionTypeChanged()
307    {
308        if (this->collisionTypeSynchronised_ != Dynamic &&
309            this->collisionTypeSynchronised_ != Kinematic &&
310            this->collisionTypeSynchronised_ != Static &&
311            this->collisionTypeSynchronised_ != None)
312        {
313            orxout(internal_error) << "Error when collsion Type was received over network. Unknown enum value:" << this->collisionTypeSynchronised_ << endl;
314        }
315        else if (this->collisionTypeSynchronised_ != collisionType_)
316        {
317            if (this->parent_)
318                orxout(internal_warning) << "Network connection tried to set the collision type of an attached WE. Ignoring." << endl;
319            else
320                this->setCollisionType(this->collisionTypeSynchronised_);
321        }
322    }
323
324    //! Network callback for this->bPhysicsActive_
325    void WorldEntity::physicsActivityChanged()
326    {
327        if (this->bPhysicsActiveSynchronised_)
328            this->activatePhysics();
329        else
330            this->deactivatePhysics();
331    }
332
333    //! Function sets whether Bullet should issue a callback on collisions
334    void WorldEntity::collisionCallbackActivityChanged()
335    {
336        if (this->hasPhysics())
337        {
338            if (this->bCollisionCallbackActive_)
339                this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() |
340                    btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
341            else
342                this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() &
343                    ~btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
344        }
345    }
346
347    //! Function sets whether Bullet should react itself to a collision
348    void WorldEntity::collisionResponseActivityChanged()
349    {
350        if (this->hasPhysics())
351        {
352            if (this->bCollisionResponseActive_)
353                this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() &
354                    ~btCollisionObject::CF_NO_CONTACT_RESPONSE);
355            else
356                this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() |
357                    btCollisionObject::CF_NO_CONTACT_RESPONSE);
358        }
359    }
360
361    /**
362    @brief
363        Attaches a child WorldEntity to this object. This calls notifyBeingAttached()
364        of the child WE.
365    @note
366        The collision shape of the child object gets attached nevertheless. That also means
367        that you can change the collision shape of the child and it correctly cascadeds the changes to this instance.
368        Be aware of this implication: When implementing attaching of kinematic objects to others, you have to change
369        this behaviour because you then might not want to merge the collision shapes.
370    */
371    void WorldEntity::attach(WorldEntity* object)
372    {
373        if (object == this)
374        {
375            orxout(internal_warning) << "Can't attach a WorldEntity to itself." << endl;
376            return;
377        }
378
379        if (!object->notifyBeingAttached(this))
380            return;
381
382        this->attachNode(object->node_);
383        this->children_.insert(object);
384
385        this->attachCollisionShape(object->collisionShape_);
386        // mass
387        this->childrenMass_ += object->getMass();
388        recalculateMassProps();
389    }
390
391    /**
392    @brief
393        Function gets called when this object is being attached to a new parent.
394
395        This operation is only allowed if the collision types "like" each other.
396        - You cannot a attach a non physical object to a physical one.
397        - Dynamic object can NOT be attached at all.
398        - It is also not possible to attach a kinematic to a dynamic one.
399        - Attaching of kinematic objects otherwise is not yet supported.
400    */
401    bool WorldEntity::notifyBeingAttached(WorldEntity* newParent)
402    {
403        // check first whether attaching is even allowed
404        if (this->hasPhysics())
405        {
406            if (!newParent->hasPhysics())
407            {
408                orxout(internal_warning) << " Cannot attach a physical object to a non physical one." << endl;
409                return false;
410            }
411            else if (this->isDynamic())
412            {
413                orxout(internal_warning) << "Cannot attach a dynamic object to a WorldEntity." << endl;
414                return false;
415            }
416            else if (this->isKinematic() && newParent->isDynamic())
417            {
418                orxout(internal_warning) << "Cannot attach a kinematic object to a dynamic one." << endl;
419                return false;
420            }
421            else if (this->isKinematic())
422            {
423                orxout(internal_warning) << "Cannot attach a kinematic object to a static or kinematic one: Not yet implemented." << endl;
424                return false;
425            }
426        }
427
428        if (this->isPhysicsActive())
429            this->bPhysicsActiveBeforeAttaching_ = true;
430        this->deactivatePhysics();
431
432        if (this->parent_)
433            this->detachFromParent();
434
435        this->parent_ = newParent;
436        this->parentID_ = newParent->getObjectID();
437
438        this->parentChanged();
439
440        // apply transform to collision shape
441        this->collisionShape_->setPosition(this->getPosition());
442        this->collisionShape_->setOrientation(this->getOrientation());
443        // TODO: Scale
444
445        return true;
446    }
447
448    /**
449    @brief
450        Detaches a child WorldEntity from this instance.
451    */
452    void WorldEntity::detach(WorldEntity* object)
453    {
454        std::set<WorldEntity*>::iterator it = this->children_.find(object);
455        if (it == this->children_.end())
456        {
457            orxout(internal_warning) << "Cannot detach an object that is not a child." << endl;
458            return;
459        }
460
461        // collision shapes
462        this->detachCollisionShape(object->collisionShape_);
463
464        // mass
465        if (object->getMass() > 0.0f)
466        {
467            this->childrenMass_ -= object->getMass();
468            recalculateMassProps();
469        }
470
471        this->detachNode(object->node_);
472        this->children_.erase(it);
473
474        object->notifyDetached();
475    }
476
477    /**
478    @brief
479        Function gets called when the object has been detached from its parent.
480    */
481    void WorldEntity::notifyDetached()
482    {
483        this->parent_ = 0;
484        this->parentID_ = OBJECTID_UNKNOWN;
485
486        this->parentChanged();
487
488        // reset orientation of the collisionShape (cannot be set within a WE usually)
489        this->collisionShape_->setPosition(Vector3::ZERO);
490        this->collisionShape_->setOrientation(Quaternion::IDENTITY);
491        // TODO: Scale
492
493        if (this->bPhysicsActiveBeforeAttaching_)
494        {
495            this->activatePhysics();
496            this->bPhysicsActiveBeforeAttaching_ = false;
497        }
498    }
499
500    //! Returns an attached object (merely for XMLPort).
501    WorldEntity* WorldEntity::getAttachedObject(unsigned int index)
502    {
503        unsigned int i = 0;
504        for (std::set<WorldEntity*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
505        {
506            if (i == index)
507                return (*it);
508            ++i;
509        }
510        return 0;
511    }
512
513    //! Attaches an Ogre::SceneNode to this WorldEntity.
514    void WorldEntity::attachNode(Ogre::SceneNode* node)
515    {
516        Ogre::Node* parent = node->getParent();
517        if (parent)
518            parent->removeChild(node);
519        this->node_->addChild(node);
520    }
521
522    //! Detaches an Ogre::SceneNode from this WorldEntity.
523    void WorldEntity::detachNode(Ogre::SceneNode* node)
524    {
525        this->node_->removeChild(node);
526//        this->getScene()->getRootSceneNode()->addChild(node);
527    }
528
529    //! Attaches an Ogre::MovableObject to this WorldEntity.
530    void WorldEntity::attachOgreObject(Ogre::MovableObject* object)
531    {
532        this->node_->attachObject(object);
533        object->setUserAny(Ogre::Any(static_cast<OrxonoxClass*>(this)));
534    }
535
536    void WorldEntity::attachOgreObject(Ogre::BillboardSet* object)
537        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
538    void WorldEntity::attachOgreObject(Ogre::Camera* object)
539        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
540    void WorldEntity::attachOgreObject(Ogre::Entity* object)
541        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
542    void WorldEntity::attachOgreObject(Ogre::ParticleSystem* object)
543        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
544
545    //! Detaches an Ogre::MovableObject from this WorldEntity.
546    void WorldEntity::detachOgreObject(Ogre::MovableObject* object)
547    {
548        object->setUserAny(Ogre::Any(static_cast<OrxonoxClass*>(NULL)));
549        this->node_->detachObject(object);
550    }
551
552    void WorldEntity::detachOgreObject(Ogre::BillboardSet* object)
553        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
554    void WorldEntity::detachOgreObject(Ogre::Camera* object)
555        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
556    void WorldEntity::detachOgreObject(Ogre::Entity* object)
557        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
558    void WorldEntity::detachOgreObject(Ogre::ParticleSystem* object)
559        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
560
561    //! Detaches an Ogre::MovableObject (by string) from this WorldEntity.
562    Ogre::MovableObject* WorldEntity::detachOgreObject(const Ogre::String& name)
563    {
564        return this->node_->detachObject(name);
565    }
566
567    //! Attaches a collision Shape to this object (delegated to the internal CompoundCollisionShape)
568    void WorldEntity::attachCollisionShape(CollisionShape* shape)
569    {
570        this->collisionShape_->attach(shape);
571        // Note: this->collisionShape_ already notifies us of any changes.
572    }
573
574    //! Detaches a collision Shape from this object (delegated to the internal CompoundCollisionShape)
575    void WorldEntity::detachCollisionShape(CollisionShape* shape)
576    {
577        // Note: The collision shapes may not be detached with this function!
578        this->collisionShape_->detach(shape);
579        // Note: this->collisionShape_ already notifies us of any changes.
580    }
581
582    //! Returns an attached collision Shape of this object (delegated to the internal CompoundCollisionShape)
583    CollisionShape* WorldEntity::getAttachedCollisionShape(unsigned int index)
584    {
585        return this->collisionShape_->getAttachedShape(index);
586    }
587
588    // Note: These functions are placed in WorldEntity.h as inline functions for the release build.
589#ifndef ORXONOX_RELEASE
590    const Vector3& WorldEntity::getPosition() const
591    {
592        return this->node_->getPosition();
593    }
594
595    const Quaternion& WorldEntity::getOrientation() const
596    {
597        return this->node_->getOrientation();
598    }
599
600    const Vector3& WorldEntity::getScale3D() const
601    {
602        return this->node_->getScale();
603    }
604#endif
605
606    //! Returns the position relative to the root space
607    const Vector3& WorldEntity::getWorldPosition() const
608    {
609        return this->node_->_getDerivedPosition();
610    }
611
612    //! Returns the orientation relative to the root space
613    const Quaternion& WorldEntity::getWorldOrientation() const
614    {
615        return this->node_->_getDerivedOrientation();
616    }
617
618    //! Returns the scaling applied relative to the root space in 3 coordinates
619    const Vector3& WorldEntity::getWorldScale3D() const
620    {
621        return this->node_->_getDerivedScale();
622    }
623
624    /**
625    @brief
626        Returns the scaling applied relative to the root space in 3 coordinates
627    @return
628        Returns the scaling if it is uniform, 1.0f otherwise.
629    */
630    float WorldEntity::getWorldScale() const
631    {
632        Vector3 scale = this->getWorldScale3D();
633        return (scale.x == scale.y && scale.x == scale.z) ? scale.x : 1;
634    }
635
636    /**
637    @brief
638        Sets the three dimensional scaling of this object.
639    @note
640        Scaling physical objects has not yet been implemented and is therefore forbidden.
641    */
642    void WorldEntity::setScale3D(const Vector3& scale)
643    {
644        // If physics is enabled scale the attached CollisionShape.
645        /*if (this->hasPhysics() && this->collisionShape_ != NULL)
646        {
647            this->collisionShape_->setScale3D(scale);
648        }*/
649
650        this->node_->setScale(scale);
651
652        this->changedScale();
653    }
654
655    /**
656    @brief
657        Translates this WorldEntity by a vector.
658    @param distance
659        The relative distance of the translation
660    @param relativeTo
661        The TransformSpace of this translation
662    */
663    void WorldEntity::translate(const Vector3& distance, TransformSpace relativeTo)
664    {
665        switch (relativeTo)
666        {
667        case WorldEntity::Local:
668            // position is relative to parent so transform downwards
669            this->setPosition(this->getPosition() + this->getOrientation() * distance);
670            break;
671        case WorldEntity::Parent:
672            this->setPosition(this->getPosition() + distance);
673            break;
674        case WorldEntity::World:
675            // position is relative to parent so transform upwards
676            if (this->node_->getParent())
677                setPosition(getPosition() + (node_->getParent()->_getDerivedOrientation().Inverse() * distance)
678                    / node_->getParent()->_getDerivedScale());
679            else
680                this->setPosition(this->getPosition() + distance);
681            break;
682        }
683    }
684
685    /**
686    @brief
687        Rotates this WorldEntity by a quaternion.
688    @param rotation
689        The desired relative rotation
690    @param relativeTo
691        The TransformSpace of this translation
692    */
693    void WorldEntity::rotate(const Quaternion& rotation, TransformSpace relativeTo)
694    {
695        switch(relativeTo)
696        {
697        case WorldEntity::Local:
698            this->setOrientation(this->getOrientation() * rotation);
699            break;
700        case WorldEntity::Parent:
701            // Rotations are normally relative to local axes, transform up
702            this->setOrientation(rotation * this->getOrientation());
703            break;
704        case WorldEntity::World:
705            // Rotations are normally relative to local axes, transform up
706            this->setOrientation(this->getOrientation() * this->getWorldOrientation().Inverse()
707                * rotation * this->getWorldOrientation());
708            break;
709        }
710    }
711
712    /**
713    @brief
714        Makes this WorldEntity look at a specific target location.
715    @param target
716        An absolute point in the space which defines the direction of the entity
717    @param relativeTo
718        The TransformSpace of this translation
719    @param localDirectionVector
720        The vector which normally describes the natural direction of the object, usually -Z.
721    */
722    void WorldEntity::lookAt(const Vector3& target, TransformSpace relativeTo, const Vector3& localDirectionVector)
723    {
724        Vector3 origin(0, 0, 0);
725        switch (relativeTo)
726        {
727        case WorldEntity::Local:
728            origin = Vector3::ZERO;
729            break;
730        case WorldEntity::Parent:
731            origin = this->getPosition();
732            break;
733        case WorldEntity::World:
734            origin = this->getWorldPosition();
735            break;
736        }
737        this->setDirection(target - origin, relativeTo, localDirectionVector);
738    }
739
740    /**
741    @brief
742        Makes this WorldEntity look in specific direction.
743    @param direction
744        A point relative to the position of the WorldEntity which defines its orientation
745    @param relativeTo
746        The TransformSpace of this translation
747    @param localDirectionVector
748        The vector which normally describes the natural direction of the object, usually -Z.
749    */
750    void WorldEntity::setDirection(const Vector3& direction, TransformSpace relativeTo, const Vector3& localDirectionVector)
751    {
752        Quaternion savedOrientation(this->getOrientation());
753        this->node_->setDirection(direction, static_cast<Ogre::Node::TransformSpace>(relativeTo), localDirectionVector);
754        Quaternion newOrientation(this->node_->getOrientation());
755        this->node_->setOrientation(savedOrientation);
756        this->setOrientation(newOrientation);
757    }
758
759    //! Activates physics if the CollisionType is not None.
760    void WorldEntity::activatePhysics()
761    {
762        if (this->isActive() && this->hasPhysics() && !this->isPhysicsActive() && !this->parent_)
763        {
764            this->getScene()->addPhysicalObject(this);
765            this->bPhysicsActive_ = true;
766            this->bPhysicsActiveSynchronised_ = true;
767        }
768    }
769
770    //! Deactivates physics but the CollisionType does not change.
771    void WorldEntity::deactivatePhysics()
772    {
773        if (this->isPhysicsActive())
774        {
775            this->getScene()->removePhysicalObject(this);
776            this->bPhysicsActive_ = false;
777            this->bPhysicsActiveSynchronised_ = false;
778        }
779    }
780
781    //! Tells whether the object has already been added to the Bullet physics World.
782    bool WorldEntity::addedToPhysicalWorld() const
783    {
784        return this->physicalBody_ && this->physicalBody_->isInWorld();
785    }
786
787    /**
788    @brief
789        Sets the CollisionType. This alters the object significantly!
790    @note
791        Operation does not work on attached WorldEntities.
792    */
793    void WorldEntity::setCollisionType(CollisionType type)
794    {
795        if (this->collisionType_ == type)
796            return;
797
798        // If we are already attached to a parent, this would be a bad idea..
799        if (this->parent_)
800        {
801            orxout(internal_warning) << "Cannot set the collision type of a WorldEntity with a parent." << endl;
802            return;
803        }
804
805        // Check for type legality. Could be StaticEntity or MobileEntity.
806        if (!this->isCollisionTypeLegal(type))
807            return;
808
809        if (this->isPhysicsActive())
810            this->deactivatePhysics();
811
812        bool bReactivatePhysics = true;
813        if (this->hasPhysics() && !this->isPhysicsActive())
814            bReactivatePhysics = false;
815
816        // Check whether we have to create or destroy.
817        if (type != None && this->collisionType_ == None)
818        {
819/*
820HACK HACK HACK
821            // Check whether there was some scaling applied.
822            if (!this->node_->getScale().positionEquals(Vector3(1, 1, 1), 0.001))
823            {
824                orxout(internal_warning) << "Cannot create a physical body if there is scaling applied to the node: Not yet implemented." << endl;
825                return;
826            }
827HACK HACK HACK
828*/
829            // Create new rigid body
830            btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, this->collisionShape_->getCollisionShape());
831            this->physicalBody_ = new btRigidBody(bodyConstructionInfo);
832            this->physicalBody_->setUserPointer(this);
833            this->physicalBody_->setActivationState(DISABLE_DEACTIVATION);
834        }
835        else if (type == None && this->collisionType_ != None)
836        {
837            // Destroy rigid body
838            assert(this->physicalBody_);
839            deactivatePhysics();
840            delete this->physicalBody_;
841            this->physicalBody_ = 0;
842            this->collisionType_ = None;
843            this->collisionTypeSynchronised_ = None;
844            return;
845        }
846
847        // Change type
848        switch (type)
849        {
850        case Dynamic:
851            this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_STATIC_OBJECT & !btCollisionObject::CF_KINEMATIC_OBJECT);
852            break;
853        case Kinematic:
854            this->physicalBody_->setCollisionFlags((this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_STATIC_OBJECT) | btCollisionObject::CF_KINEMATIC_OBJECT);
855            break;
856        case Static:
857            this->physicalBody_->setCollisionFlags((this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_KINEMATIC_OBJECT) | btCollisionObject::CF_STATIC_OBJECT);
858            break;
859        case None:
860            assert(false); // Doesn't happen
861            return;
862        }
863        this->collisionType_ = type;
864        this->collisionTypeSynchronised_ = type;
865
866        // update mass and inertia tensor
867        recalculateMassProps();
868        internalSetPhysicsProps();
869        collisionCallbackActivityChanged();
870        collisionResponseActivityChanged();
871        if (bReactivatePhysics)
872            activatePhysics();
873    }
874
875    //! Sets the CollisionType by string (used for the XMLPort)
876    void WorldEntity::setCollisionTypeStr(const std::string& typeStr)
877    {
878        const std::string& typeStrLower = getLowercase(typeStr);
879        CollisionType type;
880        if (typeStrLower == "dynamic")
881            type = Dynamic;
882        else if (typeStrLower == "static")
883            type = Static;
884        else if (typeStrLower == "kinematic")
885            type = Kinematic;
886        else if (typeStrLower == "none")
887            type = None;
888        else
889            ThrowException(ParseError, std::string("Attempting to set an unknown collision type: '") + typeStr + "'.");
890        this->setCollisionType(type);
891    }
892
893    //! Gets the CollisionType by string (used for the XMLPort)
894    std::string WorldEntity::getCollisionTypeStr() const
895    {
896        switch (this->getCollisionType())
897        {
898            case Dynamic:
899                return "dynamic";
900            case Kinematic:
901                return "kinematic";
902            case Static:
903                return "static";
904            case None:
905                return "none";
906            default:
907                assert(false);
908                return "";
909        }
910    }
911
912    /**
913    @brief
914        Recalculates the accumulated child mass and calls recalculateMassProps()
915        and notifies the parent of the change.
916    @note
917        Called by a child WE
918    */
919    void WorldEntity::notifyChildMassChanged()
920    {
921        // Note: CollisionShape changes of a child get handled over the internal CompoundCollisionShape already
922        // Recalculate mass
923        this->childrenMass_ = 0.0f;
924        for (std::set<WorldEntity*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
925            this->childrenMass_ += (*it)->getMass();
926        recalculateMassProps();
927        // Notify parent WE
928        if (this->parent_)
929            parent_->notifyChildMassChanged();
930    }
931
932    /**
933    @brief
934        Undertakes the necessary steps to change the collision shape in Bullet, even at runtime.
935    @note
936        - called by this->collisionShape_
937        - May have a REALLY big overhead when called continuously at runtime, because then we need
938          to remove the physical body from Bullet and add it again.
939    */
940    void WorldEntity::notifyCollisionShapeChanged()
941    {
942        if (hasPhysics())
943        {
944            // Bullet doesn't like sudden changes of the collision shape, so we remove and add it again
945            if (this->addedToPhysicalWorld())
946            {
947                this->deactivatePhysics();
948                this->physicalBody_->setCollisionShape(this->collisionShape_->getCollisionShape());
949                this->activatePhysics();
950            }
951            else
952                this->physicalBody_->setCollisionShape(this->collisionShape_->getCollisionShape());
953        }
954        recalculateMassProps();
955    }
956
957    //! Updates all mass dependent parameters (mass, inertia tensor and child mass)
958    void WorldEntity::recalculateMassProps()
959    {
960        // Store local inertia for faster access. Evaluates to (0,0,0) if there is no collision shape.
961        float totalMass = this->mass_ + this->childrenMass_;
962        this->collisionShape_->calculateLocalInertia(totalMass, this->localInertia_);
963        if (this->hasPhysics())
964        {
965            if (this->isStatic())
966            {
967                // Just set everything to zero
968                this->physicalBody_->setMassProps(0.0f, btVector3(0, 0, 0));
969            }
970            else if (totalMass == 0.0f)
971            {
972                // Use default values to avoid very large or very small values
973                orxout(internal_warning) << "Setting the internal physical mass to 1.0 because mass_ is 0.0" << endl;
974                btVector3 inertia(0, 0, 0);
975                this->collisionShape_->calculateLocalInertia(1.0f, inertia);
976                this->physicalBody_->setMassProps(1.0f, inertia);
977            }
978            else
979            {
980                this->physicalBody_->setMassProps(totalMass, this->localInertia_);
981            }
982        }
983    }
984
985    //! Copies our own parameters for restitution, angular factor, damping and friction to the bullet rigid body.
986    void WorldEntity::internalSetPhysicsProps()
987    {
988        if (this->hasPhysics())
989        {
990            this->physicalBody_->setRestitution(this->restitution_);
991            this->physicalBody_->setAngularFactor(this->angularFactor_);
992            this->physicalBody_->setDamping(this->linearDamping_, this->angularDamping_);
993            this->physicalBody_->setFriction(this->friction_);
994        }
995    }
996}
Note: See TracBrowser for help on using the repository browser.