Changeset 6052

Timestamp:

Nov 12, 2009, 8:00:42 PM (15 years ago)

Author:

rgrieder

Message:

Making use of Ogre::UserDefinedObject by subclassing it in WorldEntity: This way we can access a WE from an Ogre::MovableObject (e.g. Ogre::Entity or Ogre::ParticleSystem), but with a dynamic_cast of course.

Location:

code/branches/steering/src/orxonox

Files:

• graphics/Camera.cc (modified) (1 diff)
• worldentities/WorldEntity.cc (modified) (2 diffs)
• worldentities/WorldEntity.h (modified) (5 diffs)

code/branches/steering/src/orxonox/graphics/Camera.cc

@@ -61 +61 @@
 
         this->camera_ = this->getScene()->getSceneManager()->createCamera(getUniqueNumberString());
+        this->camera_->setUserObject(this);
         this->cameraNode_ = this->getScene()->getRootSceneNode()->createChildSceneNode();
         this->attachNode(this->cameraNode_);

code/branches/steering/src/orxonox/worldentities/WorldEntity.cc

@@ -472 +472 @@
     //! Attaches an Ogre::MovableObject to this WorldEntity.
     void WorldEntity::attachOgreObject(Ogre::MovableObject* object)
-        { this->node_->attachObject(object); }
+    {
+        this->node_->attachObject(object);
+        object->setUserObject(this);
+    }
+
     void WorldEntity::attachOgreObject(Ogre::BillboardSet* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::attachOgreObject(Ogre::Camera* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::attachOgreObject(Ogre::Entity* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::attachOgreObject(Ogre::ParticleSystem* object)
-        { this->node_->attachObject(object); }
+        { this->attachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
 
     //! Detaches an Ogre::MovableObject from this WorldEntity.
     void WorldEntity::detachOgreObject(Ogre::MovableObject* object)
-        { this->node_->detachObject(object); }
+    {
+        object->setUserObject(NULL);
+        this->node_->detachObject(object);
+    }
+
     void WorldEntity::detachOgreObject(Ogre::BillboardSet* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::detachOgreObject(Ogre::Camera* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::detachOgreObject(Ogre::Entity* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
     void WorldEntity::detachOgreObject(Ogre::ParticleSystem* object)
-        { this->node_->detachObject(object); }
+        { this->detachOgreObject(static_cast<Ogre::MovableObject*>(object)); }
 
     //! Detaches an Ogre::MovableObject (by string) from this WorldEntity.
@@ -913 +921 @@
     }
 
-    //! Copies our own parameters for restitution, angular factor, dampings and friction to the bullet rigid body.
+    //! Copies our own parameters for restitution, angular factor, damping and friction to the bullet rigid body.
     void WorldEntity::internalSetPhysicsProps()
     {

code/branches/steering/src/orxonox/worldentities/WorldEntity.h

@@ -33 +33 @@
 #include "OrxonoxPrereqs.h"
 
+#include <OgreUserDefinedObject.h>
 #ifdef ORXONOX_RELEASE
 #  include <OgreSceneNode.h>
@@ -55 +56 @@
 
         The basic task of the WorldEntity is provide a location, a direction and a scaling and the possibility
-        to create an entire hierarchy of derivated objects.
+        to create an entire hierarchy of derived objects.
         It is also the basis for the physics interface to the Bullet physics engine.
         Every WorldEntity can have a specific collision type: @see CollisionType
@@ -63 +64 @@
         There is also support for attaching WorldEntities with physics to each other. Currently, the collision shape
         of both objects simply get merged into one larger shape (for static collision type).
-        The phyiscal body that is internally stored and administrated has the following supported properties:
-        - Restitution, angular factor, linear damping, angular damping, fricition, mass and collision shape.
+        The physical body that is internally stored and administrated has the following supported properties:
+        - Restitution, angular factor, linear damping, angular damping, friction, mass and collision shape.
         You can get more information at the corresponding set function.
 
         Collision shapes: These are controlled by the internal WorldEntityCollisionShape. @see WorldEntityCollisionShape.
     */
-    class _OrxonoxExport WorldEntity : public BaseObject, public Synchronisable, public btMotionState
+    class _OrxonoxExport WorldEntity : public BaseObject, public Synchronisable, public btMotionState, public Ogre::UserDefinedObject
     {
         friend class Scene;
@@ -318 +319 @@
                 Sets an artificial parameter that tells how much torque is applied when you apply a non-central force.
 
-                Normally the angular factor is 1, which means it's physically 'correct'. Howerver if you have a player
+                Normally the angular factor is 1, which means it's physically 'correct'. However if you have a player
                 character that should not rotate when hit sideways, you can set the angular factor to 0.
             */
@@ -394 +395 @@
                 You can override this function in a derived class to constrain the collision to e.g. None or Dynamic.
                 A projectile may not prove very useful if there is no physical body. Simply set the CollisionType
-                in its constructor and override this method. But be careful that a derived classe's virtual functions
+                in its constructor and override this method. But be careful that a derived class's virtual functions
                 don't yet exist in the constructor if a base class.
             */