Changeset 1615

Timestamp:

Jun 22, 2008, 12:06:55 AM (16 years ago)

Author:

rgrieder

Message:

• added blankString to String so you can return ""; even if it's a const std::string&
• fixed several bugs with aspect correct and margin alignment
• added console commands for OrxonoxOverlays and OverlayGroups for rotate, scale and scroll (you can access the by name (from name=.. in xml file), e.g. "OrxonoxOverlay rotateOverlay SpeedBar 90)
• converted everything in overlays/ to 4 spaces/tab
• removed all using namespace Ogre;
• added background_ Panel to OrxonoxOverlay, since most of the derived classes can use that
• should work now, but I'll have to test on a tardis box first

Location:

code/branches/hud

Files:

• src/orxonox/CMakeLists.txt (modified) (3 diffs)
• src/orxonox/RadarListener.h (modified) (1 diff)
• src/orxonox/overlays/OrxonoxOverlay.cc (modified) (2 diffs)
• src/orxonox/overlays/OrxonoxOverlay.h (modified) (6 diffs)
• src/orxonox/overlays/OverlayGroup.cc (modified) (2 diffs)
• src/orxonox/overlays/OverlayGroup.h (modified) (2 diffs)
• src/orxonox/overlays/OverlayText.cc (moved) (moved from code/branches/hud/src/orxonox/overlays/HUDText.cc) (2 diffs)
• src/orxonox/overlays/OverlayText.h (moved) (moved from code/branches/hud/src/orxonox/overlays/HUDText.h) (2 diffs)
• src/orxonox/overlays/console/InGameConsole.cc (modified) (6 diffs)
• src/orxonox/overlays/hud/HUDBar.cc (modified) (3 diffs)
• src/orxonox/overlays/hud/HUDBar.h (modified) (1 diff)
• src/orxonox/overlays/hud/HUDFPSText.cc (modified) (1 diff)
• src/orxonox/overlays/hud/HUDFPSText.h (modified) (1 diff)
• src/orxonox/overlays/hud/HUDNavigation.cc (modified) (7 diffs)
• src/orxonox/overlays/hud/HUDNavigation.h (modified) (3 diffs)
• src/orxonox/overlays/hud/HUDRTRText.cc (modified) (1 diff)
• src/orxonox/overlays/hud/HUDRTRText.h (modified) (1 diff)
• src/orxonox/overlays/hud/HUDRadar.cc (modified) (4 diffs)
• src/orxonox/overlays/hud/HUDRadar.h (modified) (3 diffs)
• src/orxonox/overlays/hud/HUDSpeedBar.cc (modified) (1 diff)
• src/orxonox/overlays/hud/HUDSpeedBar.h (modified) (1 diff)
• src/util/String.cc (modified) (1 diff)
• src/util/String.h (modified) (1 diff)
• visual_studio/vc8/orxonox.vcproj (modified) (4 diffs)

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

@@ -4 +4 @@
   Orxonox.cc
   Radar.cc
+  RadarListener.cc
   RadarViewable.cc
   Settings.cc
@@ -9 +10 @@
   overlays/OrxonoxOverlay.cc
   overlays/OverlayGroup.cc
+  overlays/OverlayText.cc
 
   overlays/console/InGameConsole.cc
@@ -18 +20 @@
   overlays/hud/HUDRTRText.cc
   overlays/hud/HUDSpeedBar.cc
-  overlays/hud/HUDText.cc
-  overlays/hud/HUDRadar.cc
 
   tolua/tolua_bind.cc

code/branches/hud/src/orxonox/RadarListener.h

@@ -42 +42 @@
 
         virtual void displayObject(RadarViewable* viewable, bool bIsMarked) = 0;
-        virtual float getRadarSensitivity() = 0;
+        virtual float getRadarSensitivity() const = 0;
         virtual void radarTick(float dt) = 0;
     };

code/branches/hud/src/orxonox/overlays/OrxonoxOverlay.cc

@@ -30 +30 @@
 #include "OrxonoxOverlay.h"
 
+#include <cmath>
 #include <OgreOverlayManager.h>
 #include <OgrePanelOverlayElement.h>
 #include "util/Convert.h"
+#include "util/String.h"
 #include "core/CoreIncludes.h"
 #include "GraphicsEngine.h"
@@ -38 +40 @@
 namespace orxonox
 {
-  unsigned int OrxonoxOverlay::hudOverlayCounter_s = 0;
-
-  OrxonoxOverlay::OrxonoxOverlay()
-    : overlay_(0)
-    , background_(0)
-    , windowAspectRatio_(1.0f)
-    , bCorrectAspect_(false)
-    , size_(1.0f, 1.0f)
-    , sizeCorrection_(1.0f, 1.0f)
-    , angle_(0.0f)
-    , position_(0.0f, 0.0f)
-    , origin_(0.0f, 0.0f)
-  {
-    RegisterObject(OrxonoxOverlay);
-  }
-
-  OrxonoxOverlay::~OrxonoxOverlay()
-  {
-    if (this->background_)
-      Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->background_);
-  }
-
-  void OrxonoxOverlay::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-  {
-    BaseObject::XMLPort(xmlElement, mode);
-
-    if (mode == XMLPort::LoadObject)
-    {
-      overlay_ = Ogre::OverlayManager::getSingleton().create("OrxonoxOverlay"
-            + convertToString(hudOverlayCounter_s++) + "_" + this->getName());
-
-      this->windowResized(GraphicsEngine::getSingleton().getWindowWidth(),
-            GraphicsEngine::getSingleton().getWindowHeight());
-
-      // create background
-      this->background_ = static_cast<Ogre::PanelOverlayElement*>(
-          Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", getUniqueNumberStr() + "_Background"));
-      this->overlay_->add2D(this->background_);
-    }
-
-    XMLPortParam(OrxonoxOverlay, "correctAspect", setAspectCorrection, getAspectCorrection, xmlElement, mode);
-    XMLPortParam(OrxonoxOverlay, "size", setSize, getUncorrectedSize, xmlElement, mode);
-    XMLPortParam(OrxonoxOverlay, "rotation", setRotation, getRotation, xmlElement, mode);
-    XMLPortParam(OrxonoxOverlay, "origin", setOrigin, getOrigin, xmlElement, mode);
-    XMLPortParam(OrxonoxOverlay, "position", setPosition, getPosition, xmlElement, mode);
-    XMLPortParam(OrxonoxOverlay, "background", setBackgroundMaterial, getBackgroundMaterial, xmlElement, mode);
-
-    if (mode == XMLPort::LoadObject)
-    {
-      this->overlay_->show();
-      if (!this->isVisible())
-          this->overlay_->hide();
-
-      this->sizeChanged();
-      this->positionChanged();
-      this->angleChanged();
-    }
-  }
-
-  void OrxonoxOverlay::setBackgroundMaterial(const std::string& material)
-  {
-    if (this->background_ && material != "")
-      this->background_->setMaterialName(material);
-  }
-
-  std::string OrxonoxOverlay::getBackgroundMaterial() const
-  {
-    if (this->background_)
-      return this->background_->getMaterialName();
-    else
-      return "";
-  }
-
-  void OrxonoxOverlay::changedVisibility()
-  {
-    if (this->overlay_)
-    {
-      if (this->isVisible())
-        this->overlay_->show();
-      else
-        this->overlay_->hide();
-    }
-  }
-
-  void OrxonoxOverlay::windowResized(int newWidth, int newHeight)
-  {
-    this->windowAspectRatio_ = newWidth/(float)newHeight;
-
-    this->setAspectCorrection(this->bCorrectAspect_);
-  }
-
-  void OrxonoxOverlay::setAspectCorrection(bool val)
-  {
-    if (val)
-    {
-      // note: this is only an approximation that is mostly valid when the
-      // magnitude of the width is about the magnitude of the height.
-      // Correctly we would have to take the square root of width*height
-      this->sizeCorrection_.x = 2.0 / (this->windowAspectRatio_ + 1.0);
-      this->sizeCorrection_.y = this->windowAspectRatio_ * this->sizeCorrection_.x;
-    }
-    else
-    {
-      this->sizeCorrection_ = Vector2::UNIT_SCALE;
-    }
-
-    this->bCorrectAspect_ = val;
-    this->sizeChanged();
-  }
-
-  /**
+    unsigned int OrxonoxOverlay::hudOverlayCounter_s = 0;
+    std::map<std::string, OrxonoxOverlay*> OrxonoxOverlay::overlays_s;
+
+    SetConsoleCommand(OrxonoxOverlay, scaleOverlay, false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(OrxonoxOverlay, scrollOverlay, false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(OrxonoxOverlay, rotateOverlay, false).setAccessLevel(AccessLevel::User);
+
+    OrxonoxOverlay::OrxonoxOverlay()
+        : overlay_(0)
+        , background_(0)
+        , windowAspectRatio_(1.0f)
+        , bCorrectAspect_(false)
+        , size_(1.0f, 1.0f)
+        , sizeCorrection_(1.0f, 1.0f)
+        , angle_(0.0f)
+        , position_(0.0f, 0.0f)
+        , origin_(0.0f, 0.0f)
+    {
+        RegisterObject(OrxonoxOverlay);
+    }
+
+    OrxonoxOverlay::~OrxonoxOverlay()
+    {
+        if (this->background_)
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->background_);
+
+        std::map<std::string, OrxonoxOverlay*>::iterator it = overlays_s.find(this->getName());
+        if (it != overlays_s.end())
+            overlays_s.erase(it);
+    }
+
+    void OrxonoxOverlay::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    {
+        BaseObject::XMLPort(xmlElement, mode);
+
+        if (mode == XMLPort::LoadObject)
+        {
+            if (overlays_s.find(this->getName()) != overlays_s.end())
+            {
+                COUT(1) << "Overlay names should be unique or you cannnot access them via console." << std::endl;
+            }
+            overlays_s[this->getName()] = this;
+
+            overlay_ = Ogre::OverlayManager::getSingleton().create("OrxonoxOverlay_overlay_"
+                + convertToString(hudOverlayCounter_s++));
+
+            // create background
+            this->background_ = static_cast<Ogre::PanelOverlayElement*>(
+                Ogre::OverlayManager::getSingleton().createOverlayElement("Panel",
+                "OrxonoxOverlay_background_" + convertToString(hudOverlayCounter_s++)));
+            this->overlay_->add2D(this->background_);
+
+            this->windowResized(GraphicsEngine::getSingleton().getWindowWidth(),
+                GraphicsEngine::getSingleton().getWindowHeight());
+        }
+
+        XMLPortParam(OrxonoxOverlay, "correctAspect", setAspectCorrection, getAspectCorrection, xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "size", setSize, getUncorrectedSize, xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "rotation", setRotation, getRotation, xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "origin", setOrigin, getOrigin, xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "position", setPosition, getPosition, xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "background", setBackgroundMaterial, getBackgroundMaterial, xmlElement, mode);
+
+        if (mode == XMLPort::LoadObject)
+        {
+            this->overlay_->show();
+            if (!this->isVisible())
+                this->overlay_->hide();
+
+            this->sizeChanged();
+            this->positionChanged();
+            this->angleChanged();
+        }
+    }
+
+    void OrxonoxOverlay::setBackgroundMaterial(const std::string& material)
+    {
+        if (this->background_ && material != "")
+            this->background_->setMaterialName(material);
+    }
+
+    const std::string& OrxonoxOverlay::getBackgroundMaterial() const
+    {
+        if (this->background_)
+            return this->background_->getMaterialName();
+        else
+            return blankString;
+    }
+
+    void OrxonoxOverlay::changedVisibility()
+    {
+        if (this->overlay_)
+        {
+            if (this->isVisible())
+                this->overlay_->show();
+            else
+                this->overlay_->hide();
+        }
+    }
+
+    void OrxonoxOverlay::windowResized(int newWidth, int newHeight)
+    {
+        this->windowAspectRatio_ = newWidth/(float)newHeight;
+
+        this->setAspectCorrection(this->bCorrectAspect_);
+    }
+
+    void OrxonoxOverlay::setAspectCorrection(bool val)
+    {
+        this->bCorrectAspect_ = val;
+        this->sizeCorrectionChanged();
+    }
+
+    void OrxonoxOverlay::sizeCorrectionChanged()
+    {
+        if (this->bCorrectAspect_)
+        {
+            float angle = this->angle_.valueDegrees();
+            float tempAspect;
+            if (angle > 89.0 && angle < 91.0 || angle > 269 && angle < 271)
+                tempAspect = 1.0 / this->windowAspectRatio_;
+            else if (angle > 359 && angle < 1 || angle > 179 && angle < 181)
+                tempAspect = this->windowAspectRatio_;
+            else
+                tempAspect = 1.0;
+
+            // note: this is only an approximation that is mostly valid when the
+            // magnitude of the width is about the magnitude of the height.
+            // Correctly we would have to take the square root of width*height
+            this->sizeCorrection_.x = 2.0 / (tempAspect + 1.0);
+            this->sizeCorrection_.y = tempAspect * this->sizeCorrection_.x;
+        }
+        else
+        {
+            this->sizeCorrection_ = Vector2::UNIT_SCALE;
+        }
+        this->sizeChanged();
+    }
+
+    /**
     @remarks
-      This function can be overriden by any derivative.
-  */
-  void OrxonoxOverlay::sizeChanged()
-  {
-    this->overlay_->setScale(size_.x * sizeCorrection_.x, size_.y * sizeCorrection_.y);
-    positionChanged();
-  }
-
-  /**
+        This function can be overriden by any derivative.
+    */
+    void OrxonoxOverlay::sizeChanged()
+    {
+        this->overlay_->setScale(size_.x * sizeCorrection_.x, size_.y * sizeCorrection_.y);
+        positionChanged();
+    }
+
+    /**
     @remarks
-      This function can be overriden by any derivative.
-  */
-  void OrxonoxOverlay::angleChanged()
-  {
-    this->overlay_->setRotate(this->angle_);
-  }
-
-  /**
+        This function can be overriden by any derivative.
+    */
+    void OrxonoxOverlay::angleChanged()
+    {
+        this->overlay_->setRotate(this->angle_);
+        this->sizeCorrectionChanged();
+    }
+
+    /**
     @remarks
-      This function can be overriden by any derivative.
-  */
-  void OrxonoxOverlay::positionChanged()
-  {
-    Vector2 scroll = (position_ - 0.5 - size_ * sizeCorrection_ * (origin_ - 0.5)) * 2.0;
-    this->overlay_->setScroll(scroll.x, -scroll.y);
-  }
+        This function can be overriden by any derivative.
+    */
+    void OrxonoxOverlay::positionChanged()
+    {
+        float angle = abs(this->angle_.valueRadians());
+        angle -= Ogre::Math::PI * (int)(angle / (Ogre::Math::PI));
+        if (angle > Ogre::Math::PI * 0.5)
+            angle = Ogre::Math::PI - angle;
+        Vector2 actualSize = size_ * sizeCorrection_;
+        float radius = actualSize.length();
+        float phi = atan(actualSize.y / actualSize.x);
+        Vector2 boundingBox(radius * cos(angle - phi), radius * sin(angle + phi));
+        Vector2 scroll = (position_ - 0.5 - boundingBox * (origin_ - 0.5)) * 2.0;
+        this->overlay_->setScroll(scroll.x, -scroll.y);
+    }
+
+
+    /*static*/ void OrxonoxOverlay::scaleOverlay(const std::string& name, float scale)
+    {
+        std::map<std::string, OrxonoxOverlay*>::const_iterator it = overlays_s.find(name);
+        if (it != overlays_s.end())
+            (*it).second->scale(Vector2(scale, scale));
+    }
+
+    /*static*/ void OrxonoxOverlay::scrollOverlay(const std::string& name, const Vector2& scroll)
+    {
+        std::map<std::string, OrxonoxOverlay*>::const_iterator it = overlays_s.find(name);
+        if (it != overlays_s.end())
+            (*it).second->scroll(scroll);
+    }
+
+    /*static*/ void OrxonoxOverlay::rotateOverlay(const std::string& name, const Degree& angle)
+    {
+        std::map<std::string, OrxonoxOverlay*>::const_iterator it = overlays_s.find(name);
+        if (it != overlays_s.end())
+            (*it).second->rotate(angle);
+    }
 }

code/branches/hud/src/orxonox/overlays/OrxonoxOverlay.h

@@ -42 +42 @@
     {
     public:
-        Ogre::Overlay* getOverlay() { return this->overlay_; }
         OrxonoxOverlay();
         virtual ~OrxonoxOverlay();
@@ -70 +69 @@
 
         /** Sets the rotation applied to this overlay.*/
-        void setRotation(const Ogre::Radian& angle) { this->angle_ = angle; this->angleChanged(); }
+        void setRotation(const Degree& angle) { this->angle_ = angle; this->angleChanged(); }
 
         /** Gets the rotation applied to this overlay, in degrees.*/
@@ -76 +75 @@
 
         /** Adds the passed in angle to the rotation applied to this overlay. */
-        void rotate(const Radian& angle) { this->angle_ += angle; this->angleChanged(); }
+        void rotate(const Degree& angle) { this->angle_ += angle; this->angleChanged(); }
 
         /** Sets the size of this overlay. */
@@ -93 +92 @@
         void scale(Vector2 scale) { this->size_ *= scale; this->sizeChanged(); }
 
+        static void scaleOverlay(const std::string& name, float scale);
+        static void scrollOverlay(const std::string& name, const Vector2& scroll);
+        static void rotateOverlay(const std::string& name, const Degree& angle);
+
     protected:
         virtual void changedVisibility();
@@ -98 +101 @@
         virtual void angleChanged();
         virtual void positionChanged();
-        float getWindowAspectRatio() { return windowAspectRatio_; }
+        virtual void sizeCorrectionChanged();
 
         void setBackgroundMaterial(const std::string& material);
-        std::string getBackgroundMaterial() const;
+        const std::string& getBackgroundMaterial() const;
 
         Ogre::Overlay* overlay_;
         Ogre::PanelOverlayElement* background_;
-
-    private:
-        void windowResized(int newWidth, int newHeight);
-
         float windowAspectRatio_;
         bool bCorrectAspect_;
@@ -117 +116 @@
         Vector2 origin_;
 
+    private:
+        void windowResized(int newWidth, int newHeight);
+
         static unsigned int hudOverlayCounter_s;
+        static std::map<std::string, OrxonoxOverlay*> overlays_s;
   };
 }

code/branches/hud/src/orxonox/overlays/OverlayGroup.cc

@@ -30 +30 @@
 #include "OverlayGroup.h"
 
-#include <assert.h>
 #include "core/Debug.h"
 #include "core/ConsoleCommand.h"
@@ -38 +37 @@
 namespace orxonox
 {
-  CreateFactory(OverlayGroup);
+    CreateFactory(OverlayGroup);
 
-  SetConsoleCommand(OverlayGroup, toggleVisibility, false).setAccessLevel(AccessLevel::User);
-  SetConsoleCommand(OverlayGroup, scaleGroup, false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(OverlayGroup, toggleVisibility, false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(OverlayGroup, scaleGroup, false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(OverlayGroup, scrollGroup, false).setAccessLevel(AccessLevel::User);
 
-  using namespace Ogre;
+    OverlayGroup::OverlayGroup()
+        : scale_(1.0, 1.0)
+    {
+        RegisterObject(OverlayGroup);
+    }
 
-  OverlayGroup::OverlayGroup()
-    : scale_(1.0, 1.0)
-  {
-    RegisterObject(OverlayGroup);
-  }
+    OverlayGroup::~OverlayGroup()
+    {
+    }
 
-  OverlayGroup::~OverlayGroup()
-  {
-  }
+    void OverlayGroup::XMLPort(Element& xmlElement, XMLPort::Mode mode)
+    {
+        BaseObject::XMLPort(xmlElement, mode);
 
-  void OverlayGroup::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-  {
-    BaseObject::XMLPort(xmlElement, mode);
+        XMLPortParam(OverlayGroup, "scale", setScale, getScale, xmlElement, mode);
+        XMLPortParam(OverlayGroup, "scroll", setScroll, getScroll, xmlElement, mode);
+        XMLPortObject(OverlayGroup, OrxonoxOverlay, "", addElement, getElement, xmlElement, mode, false, true);
+    }
 
-    XMLPortParam(OverlayGroup, "scale", scale, getScale, xmlElement, mode);
-    XMLPortObject(OverlayGroup, OrxonoxOverlay, "", addElement, getElement, xmlElement, mode, false, true);
-  }
+    void OverlayGroup::setScale(const Vector2& scale)
+    {
+        for (std::map<std::string, OrxonoxOverlay*>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+            (*it).second->scale(scale / this->scale_);
+        this->scale_ = scale;
+    }
 
-  void OverlayGroup::scale(const Vector2& scale)
-  {
-    for (std::map<std::string, OrxonoxOverlay*>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
-      (*it).second->scale(scale);
-    this->scale_ = scale;
-  }
+    void OverlayGroup::setScroll(const Vector2& scroll)
+    {
+        for (std::map<std::string, OrxonoxOverlay*>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+            (*it).second->scroll(scroll - this->scroll_);
+        this->scroll_ = scroll;
+    }
 
-  void OverlayGroup::addElement(OrxonoxOverlay* element)
-  {
-    if (hudElements_.find(element->getName()) != hudElements_.end())
+    void OverlayGroup::addElement(OrxonoxOverlay* element)
     {
-      COUT(1) << "Ambiguous names encountered while load the HUD overlays" << std::endl;
+        if (hudElements_.find(element->getName()) != hudElements_.end())
+        {
+            COUT(1) << "Ambiguous names encountered while load the HUD overlays" << std::endl;
+        }
+        else
+            hudElements_[element->getName()] = element;
     }
-    else
-      hudElements_[element->getName()] = element;
-  }
 
-  OrxonoxOverlay* OverlayGroup::getElement(unsigned int index)
-  {
-    if (index < this->hudElements_.size())
+    OrxonoxOverlay* OverlayGroup::getElement(unsigned int index)
     {
-      std::map<std::string, OrxonoxOverlay*>::const_iterator it = hudElements_.begin();
-      for (unsigned int i = 0; i != index; ++it, ++i)
-        ;
-      return (*it).second;
+        if (index < this->hudElements_.size())
+        {
+            std::map<std::string, OrxonoxOverlay*>::const_iterator it = hudElements_.begin();
+            for (unsigned int i = 0; i != index; ++it, ++i)
+                ;
+            return (*it).second;
+        }
+        else
+            return 0;
     }
-    else
-      return 0;
-  }
 
 
-  /*static*/ void OverlayGroup::toggleVisibility(const std::string& name)
-  {
-    for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+    /*static*/ void OverlayGroup::toggleVisibility(const std::string& name)
     {
-        if ((*it)->getName() == name)
-            (*it)->setVisibility(!((*it)->isVisible()));
+        for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        {
+            if ((*it)->getName() == name)
+                (*it)->setVisibility(!((*it)->isVisible()));
+        }
     }
-  }
 
-  /*static*/ void OverlayGroup::scaleGroup(const std::string& name, float scale)
-  {
-    for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+    /*static*/ void OverlayGroup::scaleGroup(const std::string& name, float scale)
     {
-        if ((*it)->getName() == name)
-            (*it)->scale(Vector2(scale, scale));
+        for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        {
+            if ((*it)->getName() == name)
+                (*it)->scale(Vector2(scale, scale));
+        }
     }
-  }
+
+    /*static*/ void OverlayGroup::scrollGroup(const std::string& name, const Vector2& scroll)
+    {
+        for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        {
+            if ((*it)->getName() == name)
+                (*it)->scroll(scroll);
+        }
+    }
 }

code/branches/hud/src/orxonox/overlays/OverlayGroup.h

@@ -39 +39 @@
 namespace orxonox
 {
-    class HUDBar;
-    class OrxonoxOverlay;
-
     class _OrxonoxExport OverlayGroup : public BaseObject
     {
-      public:
+    public:
         OverlayGroup();
         ~OverlayGroup();
 
-        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
-
-        void scale(const Vector2& scale);
-        Vector2 getScale() const { return this->scale_; }
+        void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
         static void toggleVisibility(const std::string& name);
         static void scaleGroup(const std::string& name, float scale);
+        static void scrollGroup(const std::string& name, const Vector2& scroll);
+        static void rotateGroup(const std::string& name, Radian angle);
 
-      private:
-        OverlayGroup(const OverlayGroup& instance);
+    private:
+        void scale(const Vector2& scale) { this->setScale(scale * this->scale_); }
+        void setScale(const Vector2& scale);
+        Vector2 getScale() const { return this->scale_; }
+
+        void scroll(const Vector2& scroll) { this->setScroll(scroll + this->scroll_); }
+        void setScroll(const Vector2& scroll);
+        Vector2 getScroll() const { return this->scale_; }
 
         void addElement(OrxonoxOverlay* element);
@@ -64 +66 @@
         std::map<std::string, OrxonoxOverlay*> hudElements_;
         Vector2 scale_;
+        Vector2 scroll_;
     };
 }

code/branches/hud/src/orxonox/overlays/OverlayText.cc

@@ -28 +28 @@
 
 #include "OrxonoxStableHeaders.h"
-#include "HUDText.h"
+#include "OverlayText.h"
 
 #include <OgreOverlayManager.h>
@@ -35 +35 @@
 
 #include "util/Convert.h"
+#include "util/String.h"
 
 namespace orxonox
 {
-  CreateFactory(HUDText);
+    CreateFactory(OverlayText);
 
-  using namespace Ogre;
-
-  HUDText::HUDText()
-    : text_(0)
-  {
-    RegisterObject(HUDText);
-  }
-
-  HUDText::~HUDText()
-  {
-    if (this->isInitialized())
+    OverlayText::OverlayText()
+        : text_(0)
     {
-      if (this->text_)
-          OverlayManager::getSingleton().destroyOverlayElement(this->text_);
-    }
-  }
-
-  void HUDText::XMLPort(Element& xmlElement, XMLPort::Mode mode)
-  {
-    OrxonoxOverlay::XMLPort(xmlElement, mode);
-
-    if (mode == XMLPort::LoadObject)
-    {
-      this->text_ = static_cast<TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton().createOverlayElement("TextArea", getName() + "_Text"));
-      this->text_->setCharHeight(1.0f);
-      this->text_->setFontName("Monofur");
-
-      this->background_->addChild(this->text_);
+        RegisterObject(OverlayText);
     }
 
-    XMLPortParam(HUDText, "font", setFont, getFont, xmlElement, mode);
-    XMLPortParam(HUDText, "caption", setCaption, getCaption, xmlElement, mode);
+    OverlayText::~OverlayText()
+    {
+        if (this->text_)
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->text_);
+    }
 
-    if (mode == XMLPort::LoadObject)
+    void OverlayText::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
-      this->text_->setCaption(this->caption_);
+        if (mode == XMLPort::LoadObject)
+        {
+            // setting this to true makes the text more readable when the
+            // resolution aspect is far from 1.0
+            this->bCorrectAspect_ = true; // can be overridden by xml
+        }
+
+        OrxonoxOverlay::XMLPort(xmlElement, mode);
+
+        if (mode == XMLPort::LoadObject)
+        {
+            this->text_ = static_cast<Ogre::TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("TextArea", "OverlayText_text_" + getUniqueNumberStr()));
+            this->text_->setCharHeight(1.0f);
+            this->text_->setFontName("Monofur");
+
+            this->background_->addChild(this->text_);
+        }
+
+        XMLPortParam(OverlayText, "font", setFont, getFont, xmlElement, mode);
+        XMLPortParam(OverlayText, "caption", setCaption, getCaption, xmlElement, mode);
+        XMLPortParam(OverlayText, "textSize", setTextSize, getTextSize, xmlElement, mode);
+
+        if (mode == XMLPort::LoadObject)
+        {
+            this->text_->setCaption(this->caption_);
+        }
     }
-  }
 
-  void HUDText::setCaption(const std::string& caption)
-  {
-    this->caption_ = caption;
-  }
+    void OverlayText::setFont(const std::string& font)
+    {
+        if (this->text_ && font != "")
+            this->text_->setFontName(font);
+    }
 
-  const std::string& HUDText::getCaption() const
-  {
-    return this->caption_;
-  }
+    const std::string& OverlayText::getFont() const
+    {
+        if (this->text_)
+            return this->text_->getFontName();
+        else
+            return blankString;
+    }
 
-  void HUDText::setFont(const std::string& font)
-  {
-    if (this->text_ && font != "")
-      this->text_->setFontName(font);
-  }
-
-  std::string HUDText::getFont() const
-  {
-    if (this->text_)
-      return this->text_->getFontName();
-    else
-      return "";
-  }
+    void OverlayText::sizeChanged()
+    {
+        this->overlay_->setScale(getSize().y, getSize().y);
+        positionChanged();
+    }
 }

code/branches/hud/src/orxonox/overlays/OverlayText.h

@@ -27 +27 @@
  */
 
-#ifndef _HUDText_H__
-#define _HUDText_H__
+#ifndef _OverlayText_H__
+#define _OverlayText_H__
 
 #include "OrxonoxPrereqs.h"
@@ -34 +34 @@
 #include <string>
 #include <OgrePrerequisites.h>
-#include "overlays/OrxonoxOverlay.h"
+#include "OrxonoxOverlay.h"
 
 namespace orxonox
 {
-  class _OrxonoxExport HUDText : public OrxonoxOverlay
-  {
-  public:
-    HUDText();
-    virtual ~HUDText();
+    class _OrxonoxExport OverlayText : public OrxonoxOverlay
+    {
+    public:
+        OverlayText();
+        virtual ~OverlayText();
 
-    virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
-  protected:
-    void setCaption(const std::string& caption);
-    const std::string& getCaption() const;
-    void setFont(const std::string& font);
-    std::string getFont() const;
+    protected:
+        virtual void sizeChanged();
 
-    Ogre::TextAreaOverlayElement* text_;
+        void setCaption(const std::string& caption) { this->caption_ = caption; }
+        const std::string& getCaption() const       { return this->caption_; }
 
-  private:
-    std::string caption_;
-  };
+        void setFont(const std::string& font);
+        const std::string& getFont() const;
+
+        void setTextSize(float size) { this->setSize(Vector2(size, size)); }
+        float getTextSize() const    { return this->getUncorrectedSize().y; }
+
+        Ogre::TextAreaOverlayElement* text_;
+
+    private:
+        std::string caption_;
+    };
 }
-#endif /* _HUDText_H__ */
+#endif /* _OverlayText_H__ */

code/branches/hud/src/orxonox/overlays/console/InGameConsole.cc

@@ -54 +54 @@
     SetConsoleCommand(InGameConsole, closeConsole, true);
 
-    using namespace Ogre;
-
     /**
         @brief Constructor: Creates and initializes the InGameConsole.
@@ -119 +117 @@
 
         // create a container
-        this->consoleOverlayContainer_ = static_cast<OverlayContainer*>(ovMan->createOverlayElement("Panel", "InGameConsoleContainer"));
+        this->consoleOverlayContainer_ = static_cast<Ogre::OverlayContainer*>(ovMan->createOverlayElement("Panel", "InGameConsoleContainer"));
         this->consoleOverlayContainer_->setMetricsMode(Ogre::GMM_RELATIVE);
         this->consoleOverlayContainer_->setPosition((1 - this->relativeWidth) / 2, 0);
@@ -126 +124 @@
 
         // create BorderPanel
-        this->consoleOverlayBorder_ = static_cast<BorderPanelOverlayElement*>(ovMan->createOverlayElement("BorderPanel", "InGameConsoleBorderPanel"));
+        this->consoleOverlayBorder_ = static_cast<Ogre::BorderPanelOverlayElement*>(ovMan->createOverlayElement("BorderPanel", "InGameConsoleBorderPanel"));
         this->consoleOverlayBorder_->setMetricsMode(Ogre::GMM_PIXELS);
         this->consoleOverlayBorder_->setMaterialName("ConsoleCenter");
@@ -139 +137 @@
 
         // create the text lines
-        this->consoleOverlayTextAreas_ = new TextAreaOverlayElement*[LINES];
+        this->consoleOverlayTextAreas_ = new Ogre::TextAreaOverlayElement*[LINES];
         for (int i = 0; i < LINES; i++)
         {
-            this->consoleOverlayTextAreas_[i] = static_cast<TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleTextArea" + Ogre::StringConverter::toString(i)));
+            this->consoleOverlayTextAreas_[i] = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleTextArea" + Ogre::StringConverter::toString(i)));
             this->consoleOverlayTextAreas_[i]->setMetricsMode(Ogre::GMM_PIXELS);
             this->consoleOverlayTextAreas_[i]->setFontName("Monofur");
@@ -153 +151 @@
 
         // create cursor (also a text area overlay element)
-        this->consoleOverlayCursor_ = static_cast<TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleCursor"));
+        this->consoleOverlayCursor_ = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleCursor"));
         this->consoleOverlayCursor_->setMetricsMode(Ogre::GMM_PIXELS);
         this->consoleOverlayCursor_->setFontName("Monofur");
@@ -163 +161 @@
 
         // create noise
-        this->consoleOverlayNoise_ = static_cast<PanelOverlayElement*>(ovMan->createOverlayElement("Panel", "InGameConsoleNoise"));
+        this->consoleOverlayNoise_ = static_cast<Ogre::PanelOverlayElement*>(ovMan->createOverlayElement("Panel", "InGameConsoleNoise"));
         this->consoleOverlayNoise_->setMetricsMode(Ogre::GMM_PIXELS);
         this->consoleOverlayNoise_->setPosition(5,0);

code/branches/hud/src/orxonox/overlays/hud/HUDBar.cc

@@ -43 +43 @@
     unsigned int HUDBar::materialcount_s = 0;
 
-    using namespace Ogre;
-
     HUDBar::HUDBar()
         : bar_(0)
@@ -54 +52 @@
     HUDBar::~HUDBar()
     {
-        if (this->isInitialized())
-        {
-            if (this->bar_)
-                OverlayManager::getSingleton().destroyOverlayElement(this->bar_);
-            // FIXME: Check whether we have to delete the textureUnitState_;
-        }
+        if (this->bar_)
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->bar_);
     }
 
@@ -82 +76 @@
             barOffsetLeft_s = 0.06f;
             barOffsetTop_s = 0.0f;
-            this->bar_ = static_cast<PanelOverlayElement*>(OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "Bar" + getUniqueNumberStr()));
+
+            this->bar_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("Panel", "HUDBar_bar_" + getUniqueNumberStr()));
             this->bar_->setMaterialName(materialname);
             this->background_->addChild(bar_);

code/branches/hud/src/orxonox/overlays/hud/HUDBar.h

@@ -41 +41 @@
 namespace orxonox
 {
-  class _OrxonoxExport HUDBar : public OrxonoxOverlay
-  {
+    class _OrxonoxExport HUDBar : public OrxonoxOverlay
+    {
     public:
-      HUDBar();
-      virtual ~HUDBar();
+        HUDBar();
+        virtual ~HUDBar();
 
-      virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
-      void setValue(float value);
-      void addColour(float value, const ColourValue& colour);
-      void clearColours();
+        virtual void setValue(float value);
+        void addColour(float value, const ColourValue& colour);
+        void clearColours();
 
-      inline void setRightToLeft(bool r2l)
+        inline void setRightToLeft(bool r2l)
         { this->right2Left_ = r2l; }
-      inline bool getRightToLeft() const
+        inline bool getRightToLeft() const
         { return this->right2Left_; }
-      inline float getValue() const
+        inline float getValue() const
         { return this->value_; }
 
     private:
-      static unsigned int materialcount_s;
-      bool right2Left_;
-      bool autoColour_;                   // whether bar changes colour automatically
-      float value_;                       // progress of bar
-      Ogre::PanelOverlayElement* bar_;
-      Ogre::TextureUnitState* textureUnitState_;
-      std::map<float, ColourValue> colours_;
+        bool right2Left_;
+        bool autoColour_;                   //!< whether bar changes colour automatically
+        float value_;                       //!< progress of bar
 
-      float barWidth_s;
-      float barHeight_s;
-      float barOffsetLeft_s;
-      float barOffsetTop_s;
+        Ogre::PanelOverlayElement* bar_;
+        Ogre::TextureUnitState* textureUnitState_;
+        std::map<float, ColourValue> colours_;
+
+        float barWidth_s;
+        float barHeight_s;
+        float barOffsetLeft_s;
+        float barOffsetTop_s;
+
+        static unsigned int materialcount_s;
     };
 }

code/branches/hud/src/orxonox/overlays/hud/HUDFPSText.cc

@@ -35 +35 @@
 namespace orxonox
 {
-  CreateFactory(HUDFPSText);
+    CreateFactory(HUDFPSText);
 
-  HUDFPSText::HUDFPSText()
-  {
-    RegisterObject(HUDFPSText);
-  }
+    HUDFPSText::HUDFPSText()
+    {
+        RegisterObject(HUDFPSText);
+    }
 
-  HUDFPSText::~HUDFPSText()
-  {
-    if (this->isInitialized())
+    HUDFPSText::~HUDFPSText()
     {
     }
-  }
 
-  void HUDFPSText::tick(float dt)
-  {
-    float fps = GraphicsEngine::getSingleton().getAverageFPS();
-    this->text_->setCaption(this->getCaption() + convertToString(fps));
-  }
+    void HUDFPSText::tick(float dt)
+    {
+        float fps = GraphicsEngine::getSingleton().getAverageFPS();
+        this->text_->setCaption(this->getCaption() + convertToString(fps));
+    }
 }

code/branches/hud/src/orxonox/overlays/hud/HUDFPSText.h

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 
-#include "HUDText.h"
+#include "overlays/OverlayText.h"
 
 namespace orxonox
 {
-  class _OrxonoxExport HUDFPSText : public HUDText, public Tickable
-  {
-  public:
-    HUDFPSText();
-    virtual ~HUDFPSText();
+    class _OrxonoxExport HUDFPSText : public OverlayText, public Tickable
+    {
+    public:
+        HUDFPSText();
+        ~HUDFPSText();
 
-    //virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+    private:
+        void tick(float dt);
 
-    virtual void tick(float dt);
-
-  private:
-  };
+    private:
+    };
 }
 #endif /* _HUDFPSText_H__ */

code/branches/hud/src/orxonox/overlays/hud/HUDNavigation.cc

@@ -35 +35 @@
 
 #include "util/Math.h"
+#include "util/String.h"
 #include "core/ConsoleCommand.h"
 #include "objects/SpaceShip.h"
@@ -45 +46 @@
     CreateFactory(HUDNavigation);
 
-    //HUDNavigation* HUDNavigation::instance_s = 0;
-
-    using namespace Ogre;
-
     HUDNavigation::HUDNavigation()
-      : container_(0)
-      , navMarker_(0)
-      , aimMarker_(0)
-      , navText_(0)
+        : navMarker_(0)
+        , aimMarker_(0)
+        , navText_(0)
     {
         RegisterObject(HUDNavigation);
-        
-        /*assert(instance_s == 0); // singleton class
-        HUDNavigation::instance_s = this;*/
     }
 
     HUDNavigation::~HUDNavigation()
     {
-        if (this->isInitialized())
-        {
-            if (this->navMarker_)
-                OverlayManager::getSingleton().destroyOverlayElement(this->navMarker_);
-            if (this->navText_)
-                OverlayManager::getSingleton().destroyOverlayElement(this->navText_);
-            if (this->aimMarker_)
-                OverlayManager::getSingleton().destroyOverlayElement(this->aimMarker_);
-            if (this->container_)
-                OverlayManager::getSingleton().destroyOverlayElement(this->container_);
-        }
-
-        //HUDNavigation::instance_s = 0;
+        if (this->navMarker_)
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->navMarker_);
+        if (this->navText_)
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->navText_);
+        if (this->aimMarker_)
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->aimMarker_);
     }
 
@@ -84 +70 @@
         if (mode == XMLPort::LoadObject)
         {
-            // create container because we cannot add a Text element to an Overlay
-            container_ = static_cast<OverlayContainer*>(Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_navContainer"));
-
             // create nav text
-            navText_ = static_cast<TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton().createOverlayElement("TextArea", getName() + "_navText"));
+            navText_ = static_cast<Ogre::TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("TextArea", "HUDNavigation_navText_" + getUniqueNumberStr()));
             navText_->setCharHeight(0.05f);
             navText_->setFontName("Monofur");
 
             // create nav marker
-            navMarker_ = static_cast<PanelOverlayElement*>(OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_navMarker"));
+            navMarker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("Panel", "HUDNavigation_navMarker_" + getUniqueNumberStr()));
             navMarker_->setMaterialName("Orxonox/NavArrows");
             navMarkerSize_ = 0.05; //default
@@ -99 +84 @@
 
             // create aim marker
-            aimMarker_ = static_cast<PanelOverlayElement*>(OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_aimMarker"));
+            aimMarker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("Panel", "HUDNavigation_aimMarker_" + getUniqueNumberStr()));
             aimMarker_->setMaterialName("Orxonox/NavCrosshair");
             aimMarkerSize_ = 0.04; // default
             
-            container_->addChild(navMarker_);
-            container_->addChild(aimMarker_);
-            container_->addChild(navText_);
-            container_->show();
-
-            overlay_->add2D(container_);
+            background_->addChild(navMarker_);
+            background_->addChild(aimMarker_);
+            background_->addChild(navText_);
+
+            // hide at first
+            this->setVisibility(false);
         }
 
@@ -122 +108 @@
     }
 
-    void HUDNavigation::setNavMarkerSize(float size)
-    {
-        this->navMarkerSize_ = size;
-    }
-
-    float HUDNavigation::getNavMarkerSize() const
-    {
-        return this->navMarkerSize_;
-    }
-
-    void HUDNavigation::setAimMarkerSize(float size)
-    {
-        this->aimMarkerSize_ = size;
-    }
-
-    float HUDNavigation::getAimMarkerSize() const
-    {
-        return this->aimMarkerSize_;
-    }
-
     void HUDNavigation::setFont(const std::string& font)
     {
@@ -148 +114 @@
     }
 
-    std::string HUDNavigation::getFont() const
+    const std::string& HUDNavigation::getFont() const
     {
         if (this->navText_)
             return this->navText_->getFontName();
         else
-            return "";
+            return blankString;
     }
 
@@ -310 +276 @@
             navText_->setCharHeight(navText_->getCharHeight() * yScale);
     }
-
-    /*static*/ /*HUDNavigation& HUDNavigation::getInstance()
-    {
-        assert(instance_s);
-        return *instance_s;
-    }*/
 }

code/branches/hud/src/orxonox/overlays/hud/HUDNavigation.h

@@ -39 +39 @@
     class _OrxonoxExport HUDNavigation : public OrxonoxOverlay, public Tickable
     {
-      public:
+    public:
         HUDNavigation();
         ~HUDNavigation();
@@ -45 +45 @@
         void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
-        void tick(float dt);
-
-        float getDist2Focus() const;
-
-      protected:
+    private:
         void sizeChanged();
         void angleChanged() { }
         void positionChanged() { }
 
-      private:
-        HUDNavigation(HUDNavigation& instance);
+        void tick(float dt);
+
+        // XMLPort accessors
+        void setNavMarkerSize(float size) { this->navMarkerSize_ = size; }
+        float getNavMarkerSize() const    { return this->navMarkerSize_; }
+
+        void setAimMarkerSize(float size) { this->aimMarkerSize_ = size; }
+        float getAimMarkerSize() const    { return this->aimMarkerSize_; }
+
+        void setTextSize(float size);
+        float getTextSize() const;
+
+        void setFont(const std::string& font);
+        const std::string& getFont() const;
+
         void updateMarker();
         void updateFocus();
+        float getDist2Focus() const;
 
-        // XMLPort accessors
-        void setNavMarkerSize(float size);
-        float getNavMarkerSize() const;
-        void setAimMarkerSize(float size);
-        float getAimMarkerSize() const;
-        void setTextSize(float size);
-        float getTextSize() const;
-        void setFont(const std::string& font);
-        std::string getFont() const;
-
-        Ogre::OverlayContainer* container_;         //!< Container that holds the navigation elements
         Ogre::PanelOverlayElement* navMarker_;      //!< the panel used to show the arrow and the target marker
         float navMarkerSize_;                       //!< One paramter size of the navigation marker
@@ -76 +75 @@
         Ogre::TextAreaOverlayElement* navText_;     //!< Text overlay to display the target distance
         bool wasOutOfView_;                         //!< Performance booster variable: setMaterial is not cheap
-  };
+    };
 }
 

code/branches/hud/src/orxonox/overlays/hud/HUDRTRText.cc

@@ -35 +35 @@
 namespace orxonox
 {
-  CreateFactory(HUDRTRText);
+    CreateFactory(HUDRTRText);
 
-  HUDRTRText::HUDRTRText()
-  {
-    RegisterObject(HUDRTRText);
-  }
+    HUDRTRText::HUDRTRText()
+    {
+        RegisterObject(HUDRTRText);
+    }
 
-  HUDRTRText::~HUDRTRText()
-  {
-    if (this->isInitialized())
+    HUDRTRText::~HUDRTRText()
     {
     }
-  }
 
-  void HUDRTRText::tick(float dt)
-  {
-    float rtr = GraphicsEngine::getSingleton().getAverageRTR();
-    this->text_->setCaption(this->getCaption() + convertToString(rtr));
-  }
+    void HUDRTRText::tick(float dt)
+    {
+        float rtr = GraphicsEngine::getSingleton().getAverageRTR();
+        this->text_->setCaption(this->getCaption() + convertToString(rtr));
+    }
 }

code/branches/hud/src/orxonox/overlays/hud/HUDRTRText.h

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 
-#include "HUDText.h"
+#include "overlays/OverlayText.h"
 
 namespace orxonox
 {
-  class _OrxonoxExport HUDRTRText : public HUDText, public Tickable
-  {
-  public:
-    HUDRTRText();
-    virtual ~HUDRTRText();
+    class _OrxonoxExport HUDRTRText : public OverlayText, public Tickable
+    {
+    public:
+        HUDRTRText();
+        ~HUDRTRText();
 
-    //virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
-
-    virtual void tick(float dt);
-
-  private:
-  };
+    private:
+        void tick(float dt);
+    };
 }
 #endif /* _HUDRTRText_H__ */

code/branches/hud/src/orxonox/overlays/hud/HUDRadar.cc

@@ -45 +45 @@
     CreateFactory(HUDRadar);
 
-    using namespace Ogre;
-
     HUDRadar::HUDRadar()
         : marker_(0)
@@ -55 +53 @@
     HUDRadar::~HUDRadar()
     {
-        if (this->isInitialized())
+        if (this->marker_)
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->marker_);
+        for (std::vector<Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.begin();
+            it != this->radarDots_.end(); ++it)
         {
-            if (this->marker_)
-                OverlayManager::getSingleton().destroyOverlayElement(this->marker_);
-            for (std::vector<Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.begin();
-                it != this->radarDots_.end(); ++it)
-            {
-                OverlayManager::getSingleton().destroyOverlayElement(*it);
-            }
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(*it);
         }
     }
@@ -69 +64 @@
     void HUDRadar::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
+        if (mode == XMLPort::LoadObject)
+            this->bCorrectAspect_ = true;
+
         OrxonoxOverlay::XMLPort(xmlElement, mode);
 
         if (mode == XMLPort::LoadObject)
         {
+            marker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("Panel", "HUDRadar_marker_" + getUniqueNumberStr()));
+            marker_->setMaterialName("Orxonox/RadarMarker");
+            overlay_->add2D(marker_);
+            marker_->hide();
+
             this->sensitivity_ = 1.0f;
             this->halfDotSizeDistance_ = 3000.0f;
@@ -85 +89 @@
         shapeMaterials_[RadarViewable::Triangle] = "RadarSquare.tga";
         shapeMaterials_[RadarViewable::Square]   = "RadarSquare.tga";
-
-        if (mode == XMLPort::LoadObject)
-        {
-            marker_ = (Ogre::PanelOverlayElement*)Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_Marker");
-            marker_->setMaterialName("Orxonox/RadarMarker");
-            overlay_->add2D(marker_);
-            marker_->hide();
-        }
     }
 

code/branches/hud/src/orxonox/overlays/hud/HUDRadar.h

@@ -44 +44 @@
     class _OrxonoxExport HUDRadar : public OrxonoxOverlay, public RadarListener
     {
-      public:
+    public:
         HUDRadar();
         ~HUDRadar();
@@ -50 +50 @@
         void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
-        float getRadarSensitivity() const { return this->sensitivity_; }
-        void setRadarSensitivity(float sensitivity) { this->sensitivity_ = sensitivity; }
-
+    private:
+        // XML accessors
         float getHalfDotSizeDistance() const { return this->halfDotSizeDistance_; }
         void setHalfDotSizeDistance(float distance) { this->halfDotSizeDistance_ = distance; }
@@ -59 +58 @@
         void setMaximumDotSize(float size) { this->maximumDotSize_ = size; }
 
-      private:
+        float getRadarSensitivity() const { return this->sensitivity_; }
+        // used also by RadarListener interface!
+        void setRadarSensitivity(float sensitivity) { this->sensitivity_ = sensitivity; }
+
+        // RadarListener interface
         void displayObject(RadarViewable* viewable, bool bIsMarked);
-        float getRadarSensitivity() { return 1.0f; }
         void radarTick(float dt);
 

code/branches/hud/src/orxonox/overlays/hud/HUDSpeedBar.cc

@@ -34 +34 @@
 namespace orxonox
 {
-  CreateFactory(HUDSpeedBar);
+    CreateFactory(HUDSpeedBar);
 
-  using namespace Ogre;
+    HUDSpeedBar::HUDSpeedBar()
+    {
+        RegisterObject(HUDSpeedBar);
 
-  HUDSpeedBar::HUDSpeedBar()
-  {
-    RegisterObject(HUDSpeedBar);
+    }
 
-  }
-
-  HUDSpeedBar::~HUDSpeedBar()
-  {
-    if (this->isInitialized())
+    HUDSpeedBar::~HUDSpeedBar()
     {
     }
-  }
 
-  void HUDSpeedBar::tick(float dt)
-  {
-    SpaceShip* ship = SpaceShip::getLocalShip();
-    if (ship)
+    void HUDSpeedBar::tick(float dt)
     {
-      float v = ship->getVelocity().length();
-      float vmax = ship->getMaxSpeed();
-      this->setValue(v/vmax);
+        SpaceShip* ship = SpaceShip::getLocalShip();
+        if (ship)
+        {
+            float v = ship->getVelocity().length();
+            float vmax = ship->getMaxSpeed();
+            this->setValue(v/vmax);
+        }
     }
-  }
 }

code/branches/hud/src/orxonox/overlays/hud/HUDSpeedBar.h

@@ -37 +37 @@
 namespace orxonox
 {
-  class _OrxonoxExport HUDSpeedBar : public HUDBar, public Tickable
-  {
+    class _OrxonoxExport HUDSpeedBar : public HUDBar, public Tickable
+    {
     public:
-      HUDSpeedBar();
-      virtual ~HUDSpeedBar();
-
-      //virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
-
-      virtual void tick(float dt);
+        HUDSpeedBar();
+        ~HUDSpeedBar();
 
     private:
-
+        void tick(float dt);
     };
 }

code/branches/hud/src/util/String.cc

@@ -31 +31 @@
 #include <cctype>
 #include <iostream>
+
+/**
+    @brief Blank string as variable so you can use const std::string& even
+           if you have to return "".
+*/
+std::string blankString = "";
 
 /**

code/branches/hud/src/util/String.h

@@ -34 +34 @@
 #include <string>
 #include <sstream>
+
+extern _UtilExport std::string blankString;
 
 _UtilExport void         strip(std::string* str);

code/branches/hud/visual_studio/vc8/orxonox.vcproj

@@ -473 +473 @@
                                         >
                                 </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\overlays\OverlayText.cc"
+                                        >
+                                </File>
                                 <Filter
                                         Name="console"
@@ -506 +510 @@
                                         <File
                                                 RelativePath="..\..\src\orxonox\overlays\hud\HUDSpeedBar.cc"
-                                                >
-                                        </File>
-                                        <File
-                                                RelativePath="..\..\src\orxonox\overlays\hud\HUDText.cc"
                                                 >
                                         </File>
@@ -695 +695 @@
                                         >
                                 </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\overlays\OverlayText.h"
+                                        >
+                                </File>
                                 <Filter
                                         Name="hud"
@@ -720 +724 @@
                                         <File
                                                 RelativePath="..\..\src\orxonox\overlays\hud\HUDSpeedBar.h"
-                                                >
-                                        </File>
-                                        <File
-                                                RelativePath="..\..\src\orxonox\overlays\hud\HUDText.h"
                                                 >
                                         </File>