Changeset 11004 for code/branches/cpp11_v2/src/orxonox

Timestamp:

Dec 30, 2015, 10:07:09 PM (9 years ago)

Author:

landauf

Message:

using strongly typed enum class in WorldEntity

Location:

code/branches/cpp11_v2/src/orxonox/worldentities

Files:

• Drone.cc (modified) (1 diff)
• MobileEntity.cc (modified) (1 diff)
• StaticEntity.cc (modified) (1 diff)
• WorldEntity.cc (modified) (13 diffs)
• WorldEntity.h (modified) (5 diffs)
• pawns/FpsPlayer.cc (modified) (3 diffs)
• pawns/SpaceShip.cc (modified) (2 diffs)

code/branches/cpp11_v2/src/orxonox/worldentities/Drone.cc

@@ -49 +49 @@
         this->localAngularAcceleration_.setValue(0, 0, 0);
         this->setRadarVisibility(false);
-        this->setCollisionType(WorldEntity::Dynamic);
+        this->setCollisionType(WorldEntity::CollisionType::Dynamic);
 
         myController_ = new DroneController(this->getContext()); //!< Creates a new controller and passes our this pointer to it as creator.

code/branches/cpp11_v2/src/orxonox/worldentities/MobileEntity.cc

@@ -189 +189 @@
     bool MobileEntity::isCollisionTypeLegal(WorldEntity::CollisionType type) const
     {
-        if (type == WorldEntity::Static)
+        if (type == WorldEntity::CollisionType::Static)
         {
             orxout(internal_warning) << "Cannot tell a MobileEntity to have static collision type! Ignoring." << endl;

code/branches/cpp11_v2/src/orxonox/worldentities/StaticEntity.cc

@@ -95 +95 @@
     bool StaticEntity::isCollisionTypeLegal(WorldEntity::CollisionType type) const
     {
-        if (type == WorldEntity::Kinematic || type == WorldEntity::Dynamic)
+        if (type == WorldEntity::CollisionType::Kinematic || type == WorldEntity::CollisionType::Dynamic)
         {
             orxout(internal_warning) << "Cannot tell a StaticEntity to have kinematic or dynamic collision type! Ignoring." << endl;

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

@@ -56 +56 @@
 
     // Be sure we don't do bad conversions
-    static_assert((int)Ogre::Node::TS_LOCAL  == (int)WorldEntity::Local,  "check enum");
-    static_assert((int)Ogre::Node::TS_PARENT == (int)WorldEntity::Parent, "check enum");
-    static_assert((int)Ogre::Node::TS_WORLD  == (int)WorldEntity::World,  "check enum");
+    static_assert((int)Ogre::Node::TS_LOCAL  == (int)WorldEntity::TransformSpace::Local,  "check enum");
+    static_assert((int)Ogre::Node::TS_PARENT == (int)WorldEntity::TransformSpace::Parent, "check enum");
+    static_assert((int)Ogre::Node::TS_WORLD  == (int)WorldEntity::TransformSpace::World,  "check enum");
 
     RegisterAbstractClass(WorldEntity).inheritsFrom<BaseObject>().inheritsFrom<Synchronisable>();
@@ -95 +95 @@
         this->collisionShape_ = new WorldEntityCollisionShape(this->getContext());
         this->collisionShape_->setWorldEntityOwner(this);
-        this->collisionType_             = None;
-        this->collisionTypeSynchronised_ = None;
+        this->collisionType_             = CollisionType::None;
+        this->collisionTypeSynchronised_ = CollisionType::None;
         this->mass_                 = 1.0f;
         this->childrenMass_         = 0;
@@ -207 +207 @@
         registerVariable(this->bCollisionResponseActive_,
                                                 VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionResponseActivityChanged));
-        registerVariable((int&)this->collisionTypeSynchronised_,
+        registerVariable(this->collisionTypeSynchronised_,
                                                 VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionTypeChanged));
         registerVariable(this->bPhysicsActiveSynchronised_,
@@ -322 +322 @@
     void WorldEntity::collisionTypeChanged()
     {
-        if (this->collisionTypeSynchronised_ != Dynamic &&
-            this->collisionTypeSynchronised_ != Kinematic &&
-            this->collisionTypeSynchronised_ != Static &&
-            this->collisionTypeSynchronised_ != None)
+        if (this->collisionTypeSynchronised_ != CollisionType::Dynamic &&
+            this->collisionTypeSynchronised_ != CollisionType::Kinematic &&
+            this->collisionTypeSynchronised_ != CollisionType::Static &&
+            this->collisionTypeSynchronised_ != CollisionType::None)
         {
             orxout(internal_error) << "Error when collsion Type was received over network. Unknown enum value:" << this->collisionTypeSynchronised_ << endl;
@@ -681 +681 @@
         switch (relativeTo)
         {
-        case WorldEntity::Local:
+        case TransformSpace::Local:
             // position is relative to parent so transform downwards
             this->setPosition(this->getPosition() + this->getOrientation() * distance);
             break;
-        case WorldEntity::Parent:
+        case TransformSpace::Parent:
             this->setPosition(this->getPosition() + distance);
             break;
-        case WorldEntity::World:
+        case TransformSpace::World:
             // position is relative to parent so transform upwards
             if (this->node_->getParent())
@@ -711 +711 @@
         switch(relativeTo)
         {
-        case WorldEntity::Local:
+        case TransformSpace::Local:
             this->setOrientation(this->getOrientation() * rotation);
             break;
-        case WorldEntity::Parent:
+        case TransformSpace::Parent:
             // Rotations are normally relative to local axes, transform up
             this->setOrientation(rotation * this->getOrientation());
             break;
-        case WorldEntity::World:
+        case TransformSpace::World:
             // Rotations are normally relative to local axes, transform up
             this->setOrientation(this->getOrientation() * this->getWorldOrientation().Inverse()
@@ -741 +741 @@
         switch (relativeTo)
         {
-        case WorldEntity::Local:
+        case TransformSpace::Local:
             origin = Vector3::ZERO;
             break;
-        case WorldEntity::Parent:
+        case TransformSpace::Parent:
             origin = this->getPosition();
             break;
-        case WorldEntity::World:
+        case TransformSpace::World:
             origin = this->getWorldPosition();
             break;
@@ -831 +831 @@
 
         // Check whether we have to create or destroy.
-        if (type != None && this->collisionType_ == None)
+        if (type != CollisionType::None && this->collisionType_ == CollisionType::None)
         {
 /*
@@ -849 +849 @@
             this->physicalBody_->setActivationState(DISABLE_DEACTIVATION);
         }
-        else if (type == None && this->collisionType_ != None)
+        else if (type == CollisionType::None && this->collisionType_ != CollisionType::None)
         {
             // Destroy rigid body
@@ -856 +856 @@
             delete this->physicalBody_;
             this->physicalBody_ = nullptr;
-            this->collisionType_ = None;
-            this->collisionTypeSynchronised_ = None;
+            this->collisionType_ = CollisionType::None;
+            this->collisionTypeSynchronised_ = CollisionType::None;
             return;
         }
@@ -864 +864 @@
         switch (type)
         {
-        case Dynamic:
+        case CollisionType::Dynamic:
             this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_STATIC_OBJECT & !btCollisionObject::CF_KINEMATIC_OBJECT);
             break;
-        case Kinematic:
+        case CollisionType::Kinematic:
             this->physicalBody_->setCollisionFlags((this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_STATIC_OBJECT) | btCollisionObject::CF_KINEMATIC_OBJECT);
             break;
-        case Static:
+        case CollisionType::Static:
             this->physicalBody_->setCollisionFlags((this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_KINEMATIC_OBJECT) | btCollisionObject::CF_STATIC_OBJECT);
             break;
-        case None:
+        case CollisionType::None:
             assert(false); // Doesn't happen
             return;
@@ -895 +895 @@
         CollisionType type;
         if (typeStrLower == "dynamic")
-            type = Dynamic;
+            type = CollisionType::Dynamic;
         else if (typeStrLower == "static")
-            type = Static;
+            type = CollisionType::Static;
         else if (typeStrLower == "kinematic")
-            type = Kinematic;
+            type = CollisionType::Kinematic;
         else if (typeStrLower == "none")
-            type = None;
+            type = CollisionType::None;
         else
             ThrowException(ParseError, std::string("Attempting to set an unknown collision type: '") + typeStr + "'.");
@@ -912 +912 @@
         switch (this->getCollisionType())
         {
-            case Dynamic:
+            case CollisionType::Dynamic:
                 return "dynamic";
-            case Kinematic:
+            case CollisionType::Kinematic:
                 return "kinematic";
-            case Static:
+            case CollisionType::Static:
                 return "static";
-            case None:
+            case CollisionType::None:
                 return "none";
             default:

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

@@ -82 +82 @@
                 Enumeration denoting the spaces which a transform can be relative to.
             */
-            enum TransformSpace
+            enum class TransformSpace
             {
                 //! Transform is relative to the local space
@@ -117 +117 @@
             const Vector3& getWorldPosition() const;
 
-            void translate(const Vector3& distance, TransformSpace relativeTo = WorldEntity::Parent);
-            inline void translate(float x, float y, float z, TransformSpace relativeTo = WorldEntity::Parent)
+            void translate(const Vector3& distance, TransformSpace relativeTo = TransformSpace::Parent);
+            inline void translate(float x, float y, float z, TransformSpace relativeTo = TransformSpace::Parent)
                 { this->translate(Vector3(x, y, z), relativeTo); }
 
@@ -134 +134 @@
             const Quaternion& getWorldOrientation() const;
 
-            void rotate(const Quaternion& rotation, TransformSpace relativeTo = WorldEntity::Local);
-            inline void rotate(const Vector3& axis, const Degree& angle, TransformSpace relativeTo = WorldEntity::Local)
+            void rotate(const Quaternion& rotation, TransformSpace relativeTo = TransformSpace::Local);
+            inline void rotate(const Vector3& axis, const Degree& angle, TransformSpace relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, axis), relativeTo); }
 
-            inline void yaw(const Degree& angle, TransformSpace relativeTo = WorldEntity::Local)
+            inline void yaw(const Degree& angle, TransformSpace relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, Vector3::UNIT_Y), relativeTo); }
-            inline void pitch(const Degree& angle, TransformSpace relativeTo = WorldEntity::Local)
+            inline void pitch(const Degree& angle, TransformSpace relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, Vector3::UNIT_X), relativeTo); }
-            inline void roll(const Degree& angle, TransformSpace relativeTo = WorldEntity::Local)
+            inline void roll(const Degree& angle, TransformSpace relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, Vector3::UNIT_Z), relativeTo); }
 
-            void lookAt(const Vector3& target, TransformSpace relativeTo = WorldEntity::Parent, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
-            void setDirection(const Vector3& direction, TransformSpace relativeTo = WorldEntity::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
-            inline void setDirection(float x, float y, float z, TransformSpace relativeTo = WorldEntity::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
+            void lookAt(const Vector3& target, TransformSpace relativeTo = TransformSpace::Parent, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            void setDirection(const Vector3& direction, TransformSpace relativeTo = TransformSpace::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            inline void setDirection(float x, float y, float z, TransformSpace relativeTo = TransformSpace::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
                 { this->setDirection(Vector3(x, y, z), relativeTo, localDirectionVector); }
 
@@ -257 +257 @@
                 None:      The object has no physics at all.
             */
-            enum CollisionType
+            enum class CollisionType
             {
                 Dynamic,
@@ -266 +266 @@
 
             //! Tells whether the object has any connection to the Bullet physics engine. If hasPhysics() is false, the object may still have a velocity.
-            bool hasPhysics()       const { return getCollisionType() != None     ; }
+            bool hasPhysics()       const { return getCollisionType() != CollisionType::None     ; }
             //! @see CollisionType
-            bool isStatic()         const { return getCollisionType() == Static   ; }
+            bool isStatic()         const { return getCollisionType() == CollisionType::Static   ; }
             //! @see CollisionType
-            bool isKinematic()      const { return getCollisionType() == Kinematic; }
+            bool isKinematic()      const { return getCollisionType() == CollisionType::Kinematic; }
             //! @see CollisionType
-            bool isDynamic()        const { return getCollisionType() == Dynamic  ; }
+            bool isDynamic()        const { return getCollisionType() == CollisionType::Dynamic  ; }
             //! Tells whether physics has been activated (you can temporarily deactivate it)
             bool isPhysicsActive()  const { return this->bPhysicsActive_; }

code/branches/cpp11_v2/src/orxonox/worldentities/pawns/FpsPlayer.cc

@@ -79 +79 @@
         // FpsPlayer is always a physical object per default
         // Be aware of this call: The collision type legality check will not reach derived classes!
-        this->setCollisionType(WorldEntity::Dynamic);
+        this->setCollisionType(WorldEntity::CollisionType::Dynamic);
         // Get notification about collisions
         this->enableCollisionCallback();
@@ -130 +130 @@
     bool FpsPlayer::isCollisionTypeLegal(WorldEntity::CollisionType type) const
     {
-        if (type != WorldEntity::Dynamic)
+        if (type != WorldEntity::CollisionType::Dynamic)
         {
             orxout(internal_warning) << "Cannot tell a FpsPlayer not to be dynamic! Ignoring." << endl;
@@ -168 +168 @@
             if (!this->isInMouseLook())
             {
-                this->yaw(Radian(this->yaw_ * this->getMouseLookSpeed()), WorldEntity::Parent);
+                this->yaw(Radian(this->yaw_ * this->getMouseLookSpeed()), WorldEntity::TransformSpace::Parent);
 
                 Radian pitch = this->cameraPositionRootNode_->getOrientation().getPitch();

code/branches/cpp11_v2/src/orxonox/worldentities/pawns/SpaceShip.cc

@@ -80 +80 @@
         // SpaceShip is always a physical object per default
         // Be aware of this call: The collision type legality check will not reach derived classes!
-        this->setCollisionType(WorldEntity::Dynamic);
+        this->setCollisionType(WorldEntity::CollisionType::Dynamic);
         // Get notification about collisions
         this->enableCollisionCallback();
@@ -143 +143 @@
     bool SpaceShip::isCollisionTypeLegal(WorldEntity::CollisionType type) const
     {
-        if (type != WorldEntity::Dynamic)
+        if (type != WorldEntity::CollisionType::Dynamic)
         {
             orxout(internal_warning) << "Cannot tell a SpaceShip not to be dynamic! Ignoring." << endl;