Changeset 1989 for code/branches/objecthierarchy/src/orxonox

Timestamp:

Oct 21, 2008, 4:56:41 PM (16 years ago)

Author:

landauf

Message:

• added ControllableEntity, the baseclass of all players, vehicles and ships.
• moved Template to core
• some changes in Camera
• added 6 constants to WorldEntity to identify relative directions
• changed vom Radian to Degree as default angle unit

Location:

code/branches/objecthierarchy/src/orxonox

Files:

• CMakeLists.txt (modified) (1 diff)
• OrxonoxPrereqs.h (modified) (1 diff)
• gamestates/GSStandalone.cc (modified) (2 diffs)
• objects/Camera.cc (modified) (3 diffs)
• objects/Camera.h (modified) (2 diffs)
• objects/gametypes/Gametype.cc (modified) (1 diff)
• objects/gametypes/Gametype.h (modified) (2 diffs)
• objects/infos/PlayerInfo.cc (modified) (4 diffs)
• objects/infos/PlayerInfo.h (modified) (3 diffs)
• objects/worldentities/ControllableEntity.cc (added)
• objects/worldentities/ControllableEntity.h (added)
• objects/worldentities/MovableEntity.cc (modified) (5 diffs)
• objects/worldentities/MovableEntity.h (modified) (3 diffs)
• objects/worldentities/PositionableEntity.h (modified) (1 diff)
• objects/worldentities/WorldEntity.cc (modified) (2 diffs)
• objects/worldentities/WorldEntity.h (modified) (4 diffs)

code/branches/objecthierarchy/src/orxonox/CMakeLists.txt

@@ -43 +43 @@
   tools/WindowEventListener.cc
 
-  objects/Template.cc
-
   objects/worldentities/WorldEntity.cc
   objects/worldentities/PositionableEntity.cc
   objects/worldentities/MovableEntity.cc
+  objects/worldentities/ControllableEntity.cc
 #  objects/Backlight.cc
   objects/Camera.cc

code/branches/objecthierarchy/src/orxonox/OrxonoxPrereqs.h

@@ -81 +81 @@
 
     // objects
-    class Template;
-
     class WorldEntity;
     class PositionableEntity;

code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.cc

@@ -49 +49 @@
         GSLevel::enter();
 
+        Core::setIsStandalone(true);
         this->loadLevel();
 
@@ -58 +59 @@
         // level is loaded: we can start capturing the input
         InputManager::getInstance().requestEnterState("game");
-
-        Core::setIsStandalone(true);
     }
 

code/branches/objecthierarchy/src/orxonox/objects/Camera.cc

@@ -47 +47 @@
 namespace orxonox
 {
+  Camera::Camera()
+  {
+    RegisterObject(Camera);
 
-  Camera::Camera(Ogre::SceneNode* node)
-  {
     this->bHasFocus_ = false;
-    this->cameraNode_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
-    if( node != NULL )
-      this->setPositionNode(node);
+    this->bDrag_ = false;
+    this->cameraNode_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode();
+    this->setObjectMode(0x0);
   }
 
   Camera::~Camera()
   {
-    CameraHandler::getInstance()->releaseFocus(this);
-    GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
-  }
-
-  void Camera::setPositionNode(Ogre::SceneNode* node)
-  {
-    this->positionNode_ = node;
-    // set camera to node values according to camera mode
-  }
-
-  void Camera::setTargetNode(Ogre::SceneNode* obj)
-  {
-    this->targetNode_ = obj;
+    if (this->isInitialized())
+    {
+      CameraHandler::getInstance()->releaseFocus(this);
+      GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(this->cameraNode_->getName());
+    }
   }
 
   void Camera::tick(float dt)
   {
-    if (this->positionNode_ != NULL)
-    {
       // this stuff here may need some adjustments
-      Vector3 offset = this->positionNode_->getWorldPosition() - this->cameraNode_->getWorldPosition();
-      float coeff = 15.0f * dt;
-      if (coeff > 1.0f)
-        coeff = 1.0f;
+      float coeff = (this->bDrag_) ? min(1.0f, 15.0f * dt) : (1.0f);
 
+      Vector3 offset = this->getNode()->getWorldPosition() - this->cameraNode_->getWorldPosition();
       this->cameraNode_->translate(coeff * offset);
 
-      this->cameraNode_->setOrientation(Quaternion::Slerp(1-coeff, this->positionNode_->getWorldOrientation(), this->cameraNode_->getWorldOrientation(), false));
-    }
+      this->cameraNode_->setOrientation(Quaternion::Slerp(coeff, this->cameraNode_->getWorldOrientation(), this->getWorldOrientation(), false));
   }
 
@@ -95 +83 @@
   void Camera::update()
   {
-    if(this->positionNode_ != NULL)
-    {
-      this->cameraNode_->setPosition(this->positionNode_->getWorldPosition());
-      this->cameraNode_->setOrientation(this->positionNode_->getWorldOrientation());
-    }
+      this->cameraNode_->setPosition(this->getWorldPosition());
+      this->cameraNode_->setOrientation(this->getWorldOrientation());
   }
 
@@ -119 +104 @@
     this->cameraNode_->attachObject(this->cam_);
   }
+
+  void Camera::requestFocus()
+  {
+    CameraHandler::getInstance()->requestFocus(this);
+  }
 }

code/branches/objecthierarchy/src/orxonox/objects/Camera.h

@@ -35 +35 @@
 
 #include "OrxonoxPrereqs.h"
+#include "objects/worldentities/PositionableEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Camera
+    class _OrxonoxExport Camera : public PositionableEntity
     {
       friend class CameraHandler;
       public:
-        Camera(Ogre::SceneNode* node = NULL);
+        Camera();
         virtual ~Camera();
-
-        void setPositionNode(Ogre::SceneNode* node);
-        inline Ogre::SceneNode* getCameraNode() { return this->positionNode_; }
-        // maybe also BaseObject
-        void setTargetNode(Ogre::SceneNode* obj);
-
-        Ogre::Camera* cam_;
 
         void tick(float dt);
         void update();
-        inline bool hasFocus() { return this->bHasFocus_; }
+
+        void requestFocus();
+        inline bool hasFocus()
+            { return this->bHasFocus_; }
+
+        inline void setDrag(bool bDrag)
+            { this->bDrag_ = bDrag; }
+        inline bool getDrag() const
+            { return this->bDrag_; }
 
       private:
@@ -60 +62 @@
         void setFocus(Ogre::Camera* ogreCam);
 
-      private:
-        Ogre::SceneNode* targetNode_;
-        Ogre::SceneNode* positionNode_;
+        Ogre::Camera* cam_;
         Ogre::SceneNode* cameraNode_;
         Ogre::Vector3 oldPos;
         bool bHasFocus_;
+        bool bDrag_;
     };
 }

code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.cc

@@ -122 +122 @@
         this->players_.insert(player);
         this->playerJoined(player);
+
+        ControllableEntity* newpawn = this->defaultPawn_.fabricate();
+        player->startControl(newpawn);
     }
 
     void Gametype::removePlayer(PlayerInfo* player)
     {
+        player->stopControl();
         this->players_.erase(player);
         this->playerLeft(player);

code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.h

@@ -35 +35 @@
 
 #include "core/BaseObject.h"
+#include "core/Identifier.h"
 #include "network/ClientConnectionListener.h"
+#include "objects/worldentities/ControllableEntity.h"
 
 namespace orxonox
@@ -71 +73 @@
             std::set<PlayerInfo*> players_;
             std::map<unsigned int, PlayerInfo*> clients_;
+            SubclassIdentifier<ControllableEntity> defaultPawn_;
     };
 }

code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.cc

@@ -41 +41 @@
 #include "GraphicsEngine.h"
 #include "objects/gametypes/Gametype.h"
+#include "objects/worldentities/ControllableEntity.h"
 
 namespace orxonox
@@ -56 +57 @@
         this->bHumanPlayer_ = false;
         this->bFinishedSetup_ = false;
+
+        this->pawn_ = 0;
+        this->pawnID_ = network::OBJECTID_UNKNOWN;
 
         this->setConfigValues();
@@ -103 +107 @@
         REGISTERDATA(ping_,           network::direction::toclient);
         REGISTERDATA(bHumanPlayer_,   network::direction::toclient);
+        REGISTERDATA(pawnID_,         network::direction::toclient, new network::NetworkCallback<PlayerInfo>(this, &PlayerInfo::updatePawn));
         REGISTERDATA(bFinishedSetup_, network::direction::bidirectional, new network::NetworkCallback<PlayerInfo>(this, &PlayerInfo::finishedSetup));
     }
@@ -160 +165 @@
         }
     }
+
+    void PlayerInfo::startControl(ControllableEntity* pawn)
+    {
+        pawn->setPlayer(this);
+        this->pawn_ = pawn;
+        this->pawnID_ = pawn->getObjectID();
+    }
+
+    void PlayerInfo::stopControl()
+    {
+        this->pawn_->removePlayer();
+        this->pawn_ = 0;
+        this->pawnID_ = network::OBJECTID_UNKNOWN;
+    }
+
+    void PlayerInfo::updatePawn()
+    {
+        this->pawn_ = dynamic_cast<ControllableEntity*>(network::Synchronisable::getSynchronisable(this->pawnID_));
+        if (this->pawn_ && (this->pawn_->getPlayer() != this))
+            this->pawn_->setPlayer(this);
+    }
 }

code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.h

@@ -52 +52 @@
                 { return this->clientID_; }
 
-            inline void setHumanPlayer(bool bHumanPlayer)
-                { this->bHumanPlayer_ = bHumanPlayer; }
             inline bool isHumanPlayer() const
                 { return this->bHumanPlayer_; }
+
+            inline bool isLocalPlayer() const
+                { return this->bLocalPlayer_; }
+
+            void startControl(ControllableEntity* pawn);
+            void stopControl();
+
+            inline ControllableEntity* getPawn() const
+                { return this->pawn_; }
 
         private:
@@ -62 +69 @@
             void checkNick();
             void clientChangedName();
+            void updatePawn();
 
             unsigned int clientID_;
@@ -71 +79 @@
             std::string playerName_;
             std::string nick_;
+
+            ControllableEntity* pawn_;
+            unsigned int pawnID_;
     };
 }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.cc

@@ -44 +44 @@
         RegisterObject(MovableEntity);
 
+        this->velocity_ = Vector3::ZERO;
+        this->acceleration_ = Vector3::ZERO;
+        this->rotationAxis_ = Vector3::ZERO;
+        this->rotationRate_ = 0;
+        this->momentum_ = 0;
+
+        this->overwrite_position_ = Vector3::ZERO;
+        this->overwrite_orientation_ = Quaternion::IDENTITY;
+
         this->registerVariables();
     }
@@ -57 +66 @@
         XMLPortParamTemplate(MovableEntity, "velocity", setVelocity, getVelocity, xmlelement, mode, const Vector3&);
         XMLPortParamTemplate(MovableEntity, "rotationaxis", setRotationAxis, getRotationAxis, xmlelement, mode, const Vector3&);
-        XMLPortParamTemplate(MovableEntity, "rotationrate", setRotationRate, getRotationRate, xmlelement, mode, const Radian&);
+        XMLPortParamTemplate(MovableEntity, "rotationrate", setRotationRate, getRotationRate, xmlelement, mode, const Degree&);
     }
 
@@ -139 +148 @@
     }
 
-    void MovableEntity::yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo)
+    void MovableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         this->node_->yaw(angle, relativeTo);
@@ -145 +154 @@
     }
 
-    void MovableEntity::pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo)
+    void MovableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         this->node_->pitch(angle, relativeTo);
@@ -151 +160 @@
     }
 
-    void MovableEntity::roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo)
+    void MovableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         this->node_->roll(angle, relativeTo);

code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.h

@@ -59 +59 @@
             void setOrientation(const Quaternion& orientation);
             void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
-            void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
-            void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
-            void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
             void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
             void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
@@ -86 +86 @@
                 { return this->rotationAxis_; }
 
+            inline void setRotationRate(const Degree& angle)
+                { this->rotationRate_ = angle; }
             inline void setRotationRate(const Radian& angle)
                 { this->rotationRate_ = angle; }
-            inline void setRotationRate(const Degree& angle)
-                { this->rotationRate_ = angle; }
-            inline const Radian& getRotationRate() const
+            inline const Degree& getRotationRate() const
                 { return this->rotationRate_; }
 
+            inline void setMomentum(const Degree& angle)
+                { this->momentum_ = angle; }
             inline void setMomentum(const Radian& angle)
                 { this->momentum_ = angle; }
-            inline void setMomentum(const Degree& angle)
-                { this->momentum_ = angle; }
-            inline const Radian& getMomentum() const
+            inline const Degree& getMomentum() const
                 { return this->momentum_; }
 
@@ -111 +111 @@
             Vector3 acceleration_;
             Vector3 rotationAxis_;
-            Radian rotationRate_;
-            Radian momentum_;
+            Degree rotationRate_;
+            Degree momentum_;
 
             Vector3 overwrite_position_;

code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.h

@@ -58 +58 @@
             inline void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->node_->rotate(rotation, relativeTo); }
-            inline void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+            inline void yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->node_->yaw(angle, relativeTo); }
-            inline void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+            inline void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->node_->pitch(angle, relativeTo); }
-            inline void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+            inline void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->node_->roll(angle, relativeTo); }
             inline void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)

code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.cc

@@ -39 +39 @@
 namespace orxonox
 {
+    const Vector3 WorldEntity::FRONT = Vector3::NEGATIVE_UNIT_Z;
+    const Vector3 WorldEntity::BACK  = Vector3::UNIT_Z;
+    const Vector3 WorldEntity::LEFT  = Vector3::NEGATIVE_UNIT_X;
+    const Vector3 WorldEntity::RIGHT = Vector3::UNIT_X;
+    const Vector3 WorldEntity::DOWN  = Vector3::NEGATIVE_UNIT_Y;
+    const Vector3 WorldEntity::UP    = Vector3::UNIT_Y;
+
     WorldEntity::WorldEntity()
     {
@@ -46 +53 @@
         this->parent_ = 0;
         this->parentID_ = (unsigned int)-1;
+
+        this->node_->setPosition(Vector3::ZERO);
+        this->node_->setOrientation(Quaternion::IDENTITY);
 
         this->registerVariables();

code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.h

@@ -54 +54 @@
                 { return this->node_; }
 
+            static const Vector3 FRONT;
+            static const Vector3 BACK;
+            static const Vector3 LEFT;
+            static const Vector3 RIGHT;
+            static const Vector3 DOWN;
+            static const Vector3 UP;
+
             virtual void setPosition(const Vector3& position) = 0;
             inline void setPosition(float x, float y, float z)
@@ -71 +78 @@
             inline void setOrientation(const Vector3& axis, const Radian& angle)
                 { this->setOrientation(Quaternion(angle, axis)); }
+            inline void setOrientation(const Vector3& axis, const Degree& angle)
+                { this->setOrientation(Quaternion(angle, axis)); }
             inline const Quaternion& getOrientation() const
                 { return this->node_->getOrientation(); }
@@ -77 +86 @@
 
             virtual void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void rotate(const Vector3& axis, const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->rotate(Quaternion(angle, axis), relativeTo); }
             inline void rotate(const Vector3& axis, const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->rotate(Quaternion(angle, axis), relativeTo); }
 
-            virtual void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
-            virtual void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
-            virtual void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            virtual void yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->yaw(Degree(angle), relativeTo); }
+            virtual void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->pitch(Degree(angle), relativeTo); }
+            virtual void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->roll(Degree(angle), relativeTo); }
 
             virtual void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z) = 0;
@@ -131 +148 @@
             inline void setDirection_xmlport(const Vector3& direction)
                 { this->setDirection(direction); }
-            inline void yaw_xmlport(const Radian& angle)
+            inline void yaw_xmlport(const Degree& angle)
                 { this->yaw(angle); }
-            inline void pitch_xmlport(const Radian& angle)
+            inline void pitch_xmlport(const Degree& angle)
                 { this->pitch(angle); }
-            inline void roll_xmlport(const Radian& angle)
+            inline void roll_xmlport(const Degree& angle)
                 { this->roll(angle); }