Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 3144


Ignore:
Timestamp:
Jun 10, 2009, 10:58:53 PM (15 years ago)
Author:
rgrieder
Message:

Header file section clean up in orxonox/overlays (without stats). Also reduced dependencies as much as possible.

Location:
code/branches/pch/src/orxonox/overlays
Files:
48 edited

Legend:

Unmodified
Added
Removed
  • code/branches/pch/src/orxonox/overlays/FadeoutText.cc

    r3110 r3144  
    3030
    3131#include <OgreTextAreaOverlayElement.h>
    32 
     32#include "util/Math.h"
    3333#include "core/CoreIncludes.h"
    3434#include "core/XMLPort.h"
  • code/branches/pch/src/orxonox/overlays/FadeoutText.h

    r3099 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "tools/Timer.h"
     35#include "objects/Tickable.h"
    3436#include "overlays/OverlayText.h"
    35 #include "objects/Tickable.h"
    36 #include "tools/Timer.h"
    3737
    3838namespace orxonox
  • code/branches/pch/src/orxonox/overlays/GUIOverlay.cc

    r3110 r3144  
    2828
    2929#include "GUIOverlay.h"
     30
    3031#include <string>
    3132#include <sstream>
     33
    3234#include "core/input/InputManager.h"
    33 
    34 #include "../gui/GUIManager.h"
     35#include "core/CoreIncludes.h"
     36#include "core/XMLPort.h"
     37#include "gui/GUIManager.h"
    3538
    3639namespace orxonox
     
    5356        XMLPortParam(GUIOverlay, "guiname", setGUIName, getGUIName, xmlElement, mode);
    5457       
    55         GUIManager::getInstancePtr()->registerOverlay(this->guiName_, this);
     58        GUIManager::getInstance().registerOverlay(this->guiName_, this);
    5659    }
    5760
     
    6669            out << (long)this;
    6770            str = out.str();
    68             GUIManager::getInstancePtr()->executeCode("showCursor()");
     71            GUIManager::getInstance().executeCode("showCursor()");
    6972            InputManager::getInstance().requestEnterState("guiMouseOnly");
    70             GUIManager::getInstancePtr()->executeCode("showGUI(\"" + this->guiName_ + "\", " + str + ")");
     73            GUIManager::getInstance().executeCode("showGUI(\"" + this->guiName_ + "\", " + str + ")");
    7174        }
    7275        else
    7376        {
    74             GUIManager::getInstancePtr()->executeCode("hideGUI(\"" + this->guiName_ + "\")");
    75             GUIManager::getInstancePtr()->executeCode("hideCursor()");
     77            GUIManager::getInstance().executeCode("hideGUI(\"" + this->guiName_ + "\")");
     78            GUIManager::getInstance().executeCode("hideCursor()");
    7679            InputManager::getInstance().requestLeaveState("guiMouseOnly");
    7780        }
  • code/branches/pch/src/orxonox/overlays/GUIOverlay.h

    r3078 r3144  
    3030#define _GUIOverlay_H__
    3131
    32 
    33 #include "OrxonoxOverlay.h"
    3432#include "OrxonoxPrereqs.h"
    3533
    36 #include <OgrePrerequisites.h>
    37 
    38 #include "core/XMLPort.h"
     34#include <string>
     35#include "OrxonoxOverlay.h"
    3936
    4037namespace orxonox
  • code/branches/pch/src/orxonox/overlays/OrxonoxOverlay.h

    r2993 r3144  
    3737#include "OrxonoxPrereqs.h"
    3838
     39#include <string>
    3940#include <OgrePrerequisites.h>
    40 #include "tools/WindowEventListener.h"
     41
    4142#include "util/Math.h"
    4243#include "core/BaseObject.h"
     44#include "tools/WindowEventListener.h"
    4345
    4446namespace orxonox
     
    134136
    135137        //! Gets the current size that was set (uncorrected)
    136         const Vector2& getSize() const                   { return this->size_; }
     138        const Vector2& getSize() const            { return this->size_; }
    137139
    138140        //! Gets the actual size of the overlay on the screen (corrected)
    139         Vector2 getActualSize() const      { return this->size_ * this->sizeCorrection_; }
     141        Vector2 getActualSize() const             { return this->size_ * this->sizeCorrection_; }
    140142
    141143        //! Gets the current size correction (default: 1.0, 1.0)
     
    198200        Vector2 pickPoint_;                        //!< Point on the overlay to pick when translating
    199201        Degree angle_;                             //!< Rotation angle of the overlay
    200         RotationState rotState_;             //!< horizontal, vertical or inbetween
     202        RotationState rotState_;                   //!< horizontal, vertical or inbetween
    201203
    202204    private:
  • code/branches/pch/src/orxonox/overlays/OverlayGroup.h

    r2911 r3144  
    3939#include <set>
    4040#include <OgrePrerequisites.h>
     41#include "util/Math.h"
    4142#include "core/BaseObject.h"
    42 #include "util/Math.h"
    4343
    4444namespace orxonox
  • code/branches/pch/src/orxonox/overlays/OverlayText.cc

    r3110 r3144  
    3131#include <OgreOverlayManager.h>
    3232#include <OgrePanelOverlayElement.h>
     33#include <OgreTextAreaOverlayElement.h>
     34#include <boost/static_assert.hpp>
    3335
    3436#include "util/String.h"
     
    3638#include "core/XMLPort.h"
    3739
     40
    3841namespace orxonox
    3942{
    4043    CreateFactory(OverlayText);
     44
     45    BOOST_STATIC_ASSERT(Ogre::TextAreaOverlayElement::Left   == OverlayText::Left);
     46    BOOST_STATIC_ASSERT(Ogre::TextAreaOverlayElement::Center == OverlayText::Center);
     47    BOOST_STATIC_ASSERT(Ogre::TextAreaOverlayElement::Right  == OverlayText::Right);
    4148
    4249    OverlayText::OverlayText(BaseObject* creator)
     
    7683    }
    7784
    78     void OverlayText::setFont(const std::string& font)
    79     {
    80         if (font != "")
    81             this->text_->setFontName(font);
    82     }
    83 
    8485    void OverlayText::setAlignmentString(const std::string& alignment)
    8586    {
    8687        if (alignment == "right")
    87             this->setAlignment(Ogre::TextAreaOverlayElement::Right);
     88            this->setAlignment(OverlayText::Right);
    8889        else if (alignment == "center")
    89             this->setAlignment(Ogre::TextAreaOverlayElement::Center);
     90            this->setAlignment(OverlayText::Center);
    9091        else // "left" and default
    91             this->setAlignment(Ogre::TextAreaOverlayElement::Left);
     92            this->setAlignment(OverlayText::Left);
    9293    }
    9394
     
    120121        positionChanged();
    121122    }
     123
     124    void OverlayText::setCaption(const std::string& caption)
     125    {
     126        this->text_->setCaption(caption);
     127        this->changedCaption();
     128    }
     129    std::string OverlayText::getCaption() const
     130    {
     131        return this->text_->getCaption();
     132    }
     133
     134    void OverlayText::setFont(const std::string& font)
     135    {
     136        if (font != "")
     137            this->text_->setFontName(font);
     138    }
     139    const std::string& OverlayText::getFont() const
     140    {
     141        return this->text_->getFontName();
     142    }
     143
     144    void OverlayText::setSpaceWidth(float width)
     145    {
     146        this->text_->setSpaceWidth(width);
     147    }
     148    float OverlayText::getSpaceWidth() const
     149    {
     150        return this->text_->getSpaceWidth();
     151    }
     152
     153    void OverlayText::setColour(const ColourValue& colour)
     154    {
     155        this->text_->setColour(colour); this->changedColour();
     156    }
     157    const ColourValue& OverlayText::getColour() const
     158    {
     159        return this->text_->getColour();
     160    }
     161
     162    void OverlayText::setAlignment(OverlayText::Alignment alignment)
     163    {
     164        this->text_->setAlignment((Ogre::TextAreaOverlayElement::Alignment)alignment);
     165    }
     166    OverlayText::Alignment OverlayText::getAlignment() const
     167    {
     168        return (OverlayText::Alignment)this->text_->getAlignment();
     169    }
    122170}
  • code/branches/pch/src/orxonox/overlays/OverlayText.h

    r3099 r3144  
    3333
    3434#include <string>
    35 #include <OgrePrerequisites.h>
    36 #include <OgreTextAreaOverlayElement.h>
     35#include "util/Math.h"
    3736#include "OrxonoxOverlay.h"
    3837
     
    4241    {
    4342    public:
     43        enum Alignment
     44        {
     45            Left,
     46            Right,
     47            Center
     48        };
     49
    4450        OverlayText(BaseObject* creator);
    4551        virtual ~OverlayText();
     
    4753        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
    4854
    49         inline void setCaption(const std::string& caption) { this->text_->setCaption(caption); this->changedCaption(); }
    50         inline std::string getCaption() const              { return this->text_->getCaption(); }
     55        void setCaption(const std::string& caption);
     56        std::string getCaption() const;
    5157
    5258        void setFont(const std::string& font);
    53         inline const std::string& getFont() const { return this->text_->getFontName(); }
     59        const std::string& getFont() const;
    5460
    55         inline void setSpaceWidth(float width) { this->text_->setSpaceWidth(width); }
    56         inline float getSpaceWidth() const     { return this->text_->getSpaceWidth(); }
     61        void setSpaceWidth(float width);
     62        float getSpaceWidth() const;
    5763
    58         inline void setColour(const ColourValue& colour) { this->text_->setColour(colour); this->changedColour(); }
    59         inline const ColourValue& getColour() const      { return this->text_->getColour(); }
     64        void setColour(const ColourValue& colour);
     65        const ColourValue& getColour() const;
    6066
    61         inline void setAlignment(Ogre::TextAreaOverlayElement::Alignment alignment) { this->text_->setAlignment(alignment); }
    62         inline Ogre::TextAreaOverlayElement::Alignment getAlignment() const         { return this->text_->getAlignment(); }
     67        void setAlignment(OverlayText::Alignment alignment);
     68        OverlayText::Alignment getAlignment() const;
    6369
    6470        void setAlignmentString(const std::string& alignment);
  • code/branches/pch/src/orxonox/overlays/console/InGameConsole.cc

    r3142 r3144  
    3535#include <OgreOverlayManager.h>
    3636#include <OgreOverlayContainer.h>
     37#include <OgreBorderPanelOverlayElement.h>
     38#include <OgreTextAreaOverlayElement.h>
    3739#include <OgreFontManager.h>
    3840#include <OgreFont.h>
  • code/branches/pch/src/orxonox/overlays/console/InGameConsole.h

    r3142 r3144  
    3232
    3333#include "OrxonoxPrereqs.h"
    34 #include <OgrePrerequisites.h>
    35 #include <OgreBorderPanelOverlayElement.h>
    36 #include <OgreTextAreaOverlayElement.h>
    3734
     35#include <string>
    3836#include "core/Shell.h"
    39 #include "core/OrxonoxClass.h"
    4037#include "tools/WindowEventListener.h"
    41 
    4238
    4339namespace orxonox
    4440{
    45     class _OrxonoxExport InGameConsole : virtual public OrxonoxClass, public ShellListener, public WindowEventListener
     41    class _OrxonoxExport InGameConsole : public ShellListener, public WindowEventListener
    4642    {
    4743    public: // functions
  • code/branches/pch/src/orxonox/overlays/debug/DebugFPSText.cc

    r3110 r3144  
    2828
    2929#include "DebugFPSText.h"
    30 #include <OgreTextAreaOverlayElement.h>
     30
    3131#include "util/Convert.h"
    3232#include "core/CoreIncludes.h"
     
    5151
    5252        float fps = Game::getInstance().getAvgFPS();
    53         this->setCaption(convertToString(fps));
     53        this->setCaption(multi_cast<std::string>(fps));
    5454    }
    5555}
  • code/branches/pch/src/orxonox/overlays/debug/DebugFPSText.h

    r2087 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "objects/Tickable.h"
    3435#include "overlays/OverlayText.h"
    35 #include "objects/Tickable.h"
    3636
    3737namespace orxonox
     
    4141    public:
    4242        DebugFPSText(BaseObject* creator);
    43         ~DebugFPSText();
     43        virtual ~DebugFPSText();
    4444
    4545        virtual void tick(float dt);
  • code/branches/pch/src/orxonox/overlays/debug/DebugRTRText.cc

    r3110 r3144  
    2828
    2929#include "DebugRTRText.h"
    30 #include <OgreTextAreaOverlayElement.h>
     30
     31#include "util/Convert.h"
    3132#include "core/CoreIncludes.h"
    32 #include "util/Convert.h"
    3333#include "core/Game.h"
    3434
     
    5151
    5252        float rtr = Game::getInstance().getAvgTickTime();
    53         this->setCaption(convertToString(rtr));
     53        this->setCaption(multi_cast<std::string>(rtr));
    5454    }
    5555}
  • code/branches/pch/src/orxonox/overlays/debug/DebugRTRText.h

    r2087 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "objects/Tickable.h"
    3435#include "overlays/OverlayText.h"
    35 #include "objects/Tickable.h"
    3636
    3737namespace orxonox
     
    4141    public:
    4242        DebugRTRText(BaseObject* creator);
    43         ~DebugRTRText();
     43        virtual ~DebugRTRText();
    4444
    4545        virtual void tick(float dt);
  • code/branches/pch/src/orxonox/overlays/hud/AnnounceMessage.h

    r3099 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include <string>
     35#include "objects/GametypeMessageListener.h"
    3436#include "overlays/FadeoutText.h"
    35 #include "objects/GametypeMessageListener.h"
    3637
    3738namespace orxonox
  • code/branches/pch/src/orxonox/overlays/hud/ChatOverlay.cc

    r3142 r3144  
    3131#include <OgreTextAreaOverlayElement.h>
    3232
     33#include "util/Convert.h"
    3334#include "util/UTFStringConversions.h"
    3435#include "core/CoreIncludes.h"
     
    3637#include "core/Executor.h"
    3738
    38 #include "network/ClientInformation.h"
    39 
     39#include "tools/Timer.h"
     40#include "objects/infos/PlayerInfo.h"
    4041#include "PlayerManager.h"
    41 #include "objects/infos/PlayerInfo.h"
    42 #include "tools/Timer.h"
    43 
    44 #include "util/Convert.h"
    4542
    4643namespace orxonox
  • code/branches/pch/src/orxonox/overlays/hud/ChatOverlay.h

    r2171 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
    34 #include <OgreTextAreaOverlayElement.h>
     34#include <string>
     35#include <list>
     36#include <OgreUTFString.h>
    3537
    3638#include "network/ChatListener.h"
     
    4345        public:
    4446            ChatOverlay(BaseObject* creator);
    45             ~ChatOverlay();
     47            virtual ~ChatOverlay();
    4648
    4749            void setConfigValues();
  • code/branches/pch/src/orxonox/overlays/hud/DeathMessage.h

    r3099 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include <string>
     35#include "objects/GametypeMessageListener.h"
    3436#include "overlays/FadeoutText.h"
    35 #include "objects/GametypeMessageListener.h"
    3637
    3738namespace orxonox
  • code/branches/pch/src/orxonox/overlays/hud/GametypeStatus.cc

    r3110 r3144  
    2929#include "GametypeStatus.h"
    3030
    31 #include <OgreTextAreaOverlayElement.h>
    32 
     31#include "util/Convert.h"
    3332#include "core/CoreIncludes.h"
    34 #include "util/Convert.h"
    3533#include "objects/infos/GametypeInfo.h"
    3634#include "objects/infos/PlayerInfo.h"
  • code/branches/pch/src/orxonox/overlays/hud/GametypeStatus.h

    r2973 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "objects/Tickable.h"
    3435#include "overlays/OverlayText.h"
    35 #include "objects/Tickable.h"
    3636
    3737namespace orxonox
     
    4141        public:
    4242            GametypeStatus(BaseObject* creator);
    43             ~GametypeStatus();
     43            virtual ~GametypeStatus();
    4444
    4545            virtual void tick(float dt);
  • code/branches/pch/src/orxonox/overlays/hud/HUDBar.cc

    r3110 r3144  
    3434#include <OgreMaterialManager.h>
    3535#include <OgreTechnique.h>
     36#include <OgrePass.h>
    3637#include <OgrePanelOverlayElement.h>
    3738
  • code/branches/pch/src/orxonox/overlays/hud/HUDBar.h

    r2662 r3144  
    3535
    3636#include <map>
     37#include <vector>
    3738#include <OgrePrerequisites.h>
     39
    3840#include "util/Math.h"
     41#include "core/BaseObject.h"
    3942#include "overlays/OrxonoxOverlay.h"
    4043
     
    4548    public:
    4649        BarColour(BaseObject* creator);
    47         ~BarColour() { }
     50        virtual ~BarColour() { }
    4851
    4952        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
  • code/branches/pch/src/orxonox/overlays/hud/HUDHealthBar.cc

    r3110 r3144  
    2929#include "HUDHealthBar.h"
    3030
    31 #include <OgreOverlayManager.h>
    32 #include <OgrePanelOverlayElement.h>
    33 
     31#include "util/Convert.h"
    3432#include "core/CoreIncludes.h"
    3533#include "core/XMLPort.h"
    3634#include "objects/worldentities/pawns/Pawn.h"
    37 #include "objects/items/Engine.h"
    3835#include "overlays/OverlayGroup.h"
    39 #include "util/Convert.h"
    4036
    4137namespace orxonox
  • code/branches/pch/src/orxonox/overlays/hud/HUDHealthBar.h

    r2662 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
    34 #include "HUDBar.h"
     34#include "util/Math.h"
    3535#include "objects/Tickable.h"
    3636#include "overlays/OverlayText.h"
     37#include "HUDBar.h"
    3738
    3839namespace orxonox
     
    4243        public:
    4344            HUDHealthBar(BaseObject* creator);
    44             ~HUDHealthBar();
     45            virtual ~HUDHealthBar();
    4546
    4647            virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
     
    6465                { return this->bUseBarColour_; }
    6566
    66             inline void setTextAlignment(Ogre::TextAreaOverlayElement::Alignment alignment)
     67            inline void setTextAlignment(OverlayText::Alignment alignment)
    6768                { this->textoverlay_->setAlignment(alignment); }
    68             inline Ogre::TextAreaOverlayElement::Alignment getTextAlignment() const
     69            inline OverlayText::Alignment getTextAlignment() const
    6970                { return this->textoverlay_->getAlignment(); }
    7071
  • code/branches/pch/src/orxonox/overlays/hud/HUDNavigation.cc

    r3110 r3144  
    3636#include "util/String.h"
    3737#include "util/Convert.h"
    38 #include "core/ConsoleCommand.h"
    3938#include "core/CoreIncludes.h"
    4039#include "core/XMLPort.h"
  • code/branches/pch/src/orxonox/overlays/hud/HUDNavigation.h

    r2087 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include <string>
    3435#include <OgrePrerequisites.h>
     36#include "objects/Tickable.h"
    3537#include "overlays/OrxonoxOverlay.h"
    36 #include "objects/Tickable.h"
    3738
    3839namespace orxonox
     
    4243    public:
    4344        HUDNavigation(BaseObject* creator);
    44         ~HUDNavigation();
     45        virtual ~HUDNavigation();
    4546
    4647        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
  • code/branches/pch/src/orxonox/overlays/hud/HUDRadar.cc

    r3110 r3144  
    3535#include "util/Math.h"
    3636#include "util/String.h"
    37 #include "core/ConsoleCommand.h"
    3837#include "core/CoreIncludes.h"
    3938#include "core/XMLPort.h"
    40 #include "objects/Radar.h"
     39#include "tools/TextureGenerator.h"
    4140#include "objects/worldentities/WorldEntity.h"
    4241#include "objects/worldentities/pawns/Pawn.h"
    43 #include "tools/TextureGenerator.h"
    4442
    4543namespace orxonox
  • code/branches/pch/src/orxonox/overlays/hud/HUDRadar.h

    r2662 r3144  
    3333#include "OrxonoxPrereqs.h"
    3434
     35#include <map>
    3536#include <vector>
    36 #include <map>
    3737#include <OgrePrerequisites.h>
     38
    3839#include "overlays/OrxonoxOverlay.h"
    3940#include "objects/RadarListener.h"
     
    4647    public:
    4748        HUDRadar(BaseObject* creator);
    48         ~HUDRadar();
     49        virtual ~HUDRadar();
    4950
    5051        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
  • code/branches/pch/src/orxonox/overlays/hud/HUDSpeedBar.cc

    r3110 r3144  
    2929
    3030#include "HUDSpeedBar.h"
     31
    3132#include "core/CoreIncludes.h"
    3233#include "objects/worldentities/pawns/SpaceShip.h"
  • code/branches/pch/src/orxonox/overlays/hud/HUDSpeedBar.h

    r2662 r3144  
    3333#include "OrxonoxPrereqs.h"
    3434
     35#include "objects/Tickable.h"
    3536#include "HUDBar.h"
    36 #include "objects/Tickable.h"
    3737
    3838namespace orxonox
     
    4242    public:
    4343        HUDSpeedBar(BaseObject* creator);
    44         ~HUDSpeedBar();
     44        virtual ~HUDSpeedBar();
    4545
    4646        virtual void tick(float dt);
  • code/branches/pch/src/orxonox/overlays/hud/HUDTimer.cc

    r3110 r3144  
    2929#include "HUDTimer.h"
    3030
     31#include "util/Convert.h"
    3132#include "core/CoreIncludes.h"
    32 #include "util/Convert.h"
    3333#include "objects/worldentities/ControllableEntity.h"
    3434#include "objects/gametypes/Gametype.h"
     
    3636namespace orxonox
    3737{
    38   CreateFactory(HUDTimer);
     38    CreateFactory(HUDTimer);
    3939
    40   HUDTimer::HUDTimer(BaseObject* creator) : OverlayText(creator)
    41   {
    42     RegisterObject(HUDTimer);
     40    HUDTimer::HUDTimer(BaseObject* creator) : OverlayText(creator)
     41    {
     42        RegisterObject(HUDTimer);
    4343
    44     this->owner_ = 0;
    45   }
     44        this->owner_ = 0;
     45    }
    4646
    47   HUDTimer::~HUDTimer()
    48   {
    49   }
     47    HUDTimer::~HUDTimer()
     48    {
     49    }
    5050
    51   void HUDTimer::tick(float dt)
    52   {
    53     SUPER(HUDTimer, tick, dt);
     51    void HUDTimer::tick(float dt)
     52    {
     53        SUPER(HUDTimer, tick, dt);
    5454
    55     Gametype* gametype = this->getGametype();
    56    
    57     if(gametype)
     55        Gametype* gametype = this->getGametype();
     56
     57        if (gametype)
     58        {
     59            if (gametype->getTimerIsActive())
     60            {
     61                this->setCaption(convertToString((int)gametype->getTime() + 1));
     62            }
     63        }
     64    }
     65
     66    void HUDTimer::changedOwner()
    5867    {
    59       if (gametype->getTimerIsActive())
    60       {
    61         this->setCaption(convertToString((int)gametype->getTime() + 1));
    62       }
     68        SUPER(HUDTimer, changedOwner);
     69
     70        this->owner_ = dynamic_cast<ControllableEntity*>(this->getOwner());
    6371    }
    64   }
    65 
    66   void HUDTimer::changedOwner()
    67   {
    68     SUPER(HUDTimer, changedOwner);
    69 
    70     this->owner_ = dynamic_cast<ControllableEntity*>(this->getOwner());
    71   }
    7272}
  • code/branches/pch/src/orxonox/overlays/hud/HUDTimer.h

    r3033 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "objects/Tickable.h"
    3435#include "overlays/OverlayText.h"
    35 #include "objects/Tickable.h"
    3636
    3737namespace orxonox
    3838{
    39   class _OrxonoxExport HUDTimer : public OverlayText, public Tickable
    40   {
     39    class _OrxonoxExport HUDTimer : public OverlayText, public Tickable
     40    {
    4141    public:
    42       HUDTimer(BaseObject* creator);
    43       ~HUDTimer();
     42        HUDTimer(BaseObject* creator);
     43        virtual ~HUDTimer();
    4444
    45       virtual void tick(float dt);
     45        virtual void tick(float dt);
    4646
    47       virtual void changedOwner();
     47        virtual void changedOwner();
    4848
    49       private:
     49    private:
    5050        ControllableEntity* owner_;
    51   };
     51    };
    5252}
    5353#endif /* _HUDTimer_H__ */
  • code/branches/pch/src/orxonox/overlays/hud/KillMessage.h

    r3099 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include <string>
     35#include "objects/GametypeMessageListener.h"
    3436#include "overlays/FadeoutText.h"
    35 #include "objects/GametypeMessageListener.h"
    3637
    3738namespace orxonox
  • code/branches/pch/src/orxonox/overlays/hud/PongScore.cc

    r3110 r3144  
    2929#include "PongScore.h"
    3030
    31 #include <OgreTextAreaOverlayElement.h>
    32 
     31#include "util/Convert.h"
    3332#include "core/CoreIncludes.h"
    3433#include "core/XMLPort.h"
    35 #include "util/Convert.h"
    3634#include "objects/gametypes/Pong.h"
    3735#include "objects/infos/PlayerInfo.h"
  • code/branches/pch/src/orxonox/overlays/hud/PongScore.h

    r3078 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "objects/Tickable.h"
    3435#include "overlays/OverlayText.h"
    35 #include "objects/Tickable.h"
    3636
    3737namespace orxonox
     
    4141        public:
    4242            PongScore(BaseObject* creator);
    43             ~PongScore();
     43            virtual ~PongScore();
    4444
    4545            virtual void tick(float dt);
  • code/branches/pch/src/orxonox/overlays/hud/TeamBaseMatchScore.cc

    r3110 r3144  
    2828
    2929#include "TeamBaseMatchScore.h"
    30 
    31 #include <OgreTextAreaOverlayElement.h>
    3230
    3331#include "core/CoreIncludes.h"
  • code/branches/pch/src/orxonox/overlays/hud/TeamBaseMatchScore.h

    r3104 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "objects/Tickable.h"
    3435#include "overlays/OverlayText.h"
    35 #include "objects/Tickable.h"
    3636
    3737namespace orxonox
     
    4141        public:
    4242            TeamBaseMatchScore(BaseObject* creator);
    43             ~TeamBaseMatchScore();
     43            virtual ~TeamBaseMatchScore();
    4444
    4545            virtual void tick(float dt);
  • code/branches/pch/src/orxonox/overlays/hud/UnderAttackHealthBar.h

    r3104 r3144  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "util/Math.h"
     35#include "tools/Timer.h"
    3436#include "HUDHealthBar.h"
    35 #include "tools/Timer.h"
    3637
    3738namespace orxonox
  • code/branches/pch/src/orxonox/overlays/map/Map.cc

    r3110 r3144  
    2424 *
    2525 */
     26
    2627#include "Map.h"
    2728
    2829#include <string>
    29 #include "util/String.h"
     30
     31#include <OgreBorderPanelOverlayElement.h>
     32#include <OgreCamera.h>
     33#include <OgreHardwarePixelBuffer.h>
     34#include <OgreMaterialManager.h>
     35#include <OgreMovablePlane.h>
     36#include <OgreOverlay.h>
     37#include <OgreOverlayContainer.h>
     38#include <OgreOverlayManager.h>
     39#include <OgrePass.h>
     40#include <OgreRenderTexture.h>
     41#include <OgreResourceGroupManager.h>
     42#include <OgreRoot.h>
    3043#include <OgreSceneManager.h>
    3144#include <OgreSceneNode.h>
    32 #include <OgreEntity.h>
    33 #include <OgreNode.h>
    34 
    35 
    36 #include <OgreRenderWindow.h>
    37 #include <OgreRenderTexture.h>
     45#include <OgreTechnique.h>
    3846#include <OgreTexture.h>
     47#include <OgreTextureManager.h>
    3948#include <OgreViewport.h>
    4049
    41 #include <OgreMaterialManager.h>
    42 #include <OgreRoot.h>
    43 #include <OgreHardwarePixelBuffer.h>
    44 #include "objects/worldentities/ControllableEntity.h"
    45 #include "objects/worldentities/CameraPosition.h"
    46 
    47 #include <OgreOverlay.h>
    48 #include <OgreMovablePlane.h>
    49 #include <OgreOverlayElement.h>
    50 #include <OgreOverlayManager.h>
    51 #include <OgreOverlayContainer.h>
     50#include "core/ConsoleCommand.h"
    5251#include "core/CoreIncludes.h"
    53 #include "core/ConfigValueIncludes.h"
    54 #include "core/ConsoleCommand.h"
     52#include "core/Iterator.h"
     53#include "core/XMLPort.h"
    5554#include "objects/Scene.h"
    5655#include "objects/RadarViewable.h"
    5756#include "objects/controllers/HumanController.h"
     57#include "objects/worldentities/CameraPosition.h"
     58#include "objects/worldentities/ControllableEntity.h"
    5859
    5960 namespace orxonox
  • code/branches/pch/src/orxonox/overlays/map/Map.h

    r3101 r3144  
    2525 */
    2626
    27 #ifndef _MAP_H__
    28 #define _MAP_H__
     27#ifndef _Map_H__
     28#define _Map_H__
     29
     30#include "OrxonoxPrereqs.h"
    2931
    3032#include <string>
    31 #include "OrxonoxPrereqs.h"
    32 #include <OgrePrerequisites.h>
    33 #include <OgreSceneManager.h>
    34 #include <OgreSceneNode.h>
    35 #include <OgreEntity.h>
    36 #include <OgreOverlay.h>
    37 #include <OgreOverlayElement.h>
    38 #include <OgreOverlayManager.h>
    39 #include <OgreOverlayContainer.h>
    40 #include <OgreMovablePlane.h>
     33#include <OgreMaterial.h>
    4134
    42 #include <OgreBorderPanelOverlayElement.h>
    43 #include <OgreTextAreaOverlayElement.h>
    44 
     35#include "util/UtilPrereqs.h"
     36#include "objects/Tickable.h"
    4537#include "overlays/OrxonoxOverlay.h"
    46 #include "objects/Tickable.h"
    47 
    48 
    4938
    5039namespace orxonox
     
    5544    public: // functions
    5645        Map(BaseObject* creator);
    57         ~Map();
     46        virtual ~Map();
    5847
    5948        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
     
    126115}
    127116
    128 #endif /* _MAP_H__ */
     117#endif /* _Map_H__ */
  • code/branches/pch/src/orxonox/overlays/notifications/Notification.cc

    r3110 r3144  
    3535
    3636#include "core/CoreIncludes.h"
    37 #include "util/Exception.h"
    38 
    3937#include "NotificationManager.h"
    4038
     
    4846    Notification::Notification(BaseObject* creator) : BaseObject(creator)
    4947    {
     48        RegisterObject(Notification);
    5049        this->initialize();
    5150    }
     
    7675    void Notification::initialize(void)
    7776    {
    78         RegisterObject(Notification);
    79        
    8077        this->message_ = "";
    8178        this->sender_ = NotificationManager::NONE;
  • code/branches/pch/src/orxonox/overlays/notifications/Notification.h

    r3034 r3144  
    3838
    3939#include <string>
    40 
    4140#include "core/BaseObject.h"
    4241
  • code/branches/pch/src/orxonox/overlays/notifications/NotificationManager.cc

    r3110 r3144  
    3434#include "NotificationManager.h"
    3535
     36#include <set>
     37
    3638#include "core/CoreIncludes.h"
    37 
    38 #include <set>
    39 
    4039#include "Notification.h"
    4140#include "NotificationQueue.h"
  • code/branches/pch/src/orxonox/overlays/notifications/NotificationManager.h

    r3034 r3144  
    3737#include "OrxonoxPrereqs.h"
    3838
    39 #include "core/OrxonoxClass.h"
    40 
     39#include <ctime>
    4140#include <map>
    4241#include <string>
    43 #include <ctime>
    44 
    45 #include "NotificationOverlay.h"
     42#include "core/OrxonoxClass.h"
    4643
    4744namespace orxonox
  • code/branches/pch/src/orxonox/overlays/notifications/NotificationOverlay.cc

    r3110 r3144  
    3434#include "NotificationOverlay.h"
    3535
    36 #include <OgreOverlayManager.h>
    37 #include <OgreTextAreaOverlayElement.h>
    38 #include <OgrePanelOverlayElement.h>
    39 
     36#include "util/Exception.h"
    4037#include "core/CoreIncludes.h"
    41 #include "util/Exception.h"
    42 
    4338#include "Notification.h"
    4439#include "NotificationQueue.h"
     
    5348    NotificationOverlay::NotificationOverlay(BaseObject* creator) : OverlayText(creator)
    5449    {
     50        RegisterObject(NotificationOverlay);
    5551        this->initialize();
    5652    }
     
    8783    void NotificationOverlay::initialize(void)
    8884    {
    89         RegisterObject(NotificationOverlay);
    90        
    9185        this->queue_ = NULL;
    9286    }
  • code/branches/pch/src/orxonox/overlays/notifications/NotificationOverlay.h

    r3078 r3144  
    3838#include "OrxonoxPrereqs.h"
    3939
     40#include <string>
    4041#include "orxonox/overlays/OverlayText.h"
    41 
    42 #include <string>
    43 #include <set>
    44 #include <OgrePrerequisites.h>
    45 #include <OgreTextAreaOverlayElement.h>
    4642
    4743namespace orxonox
  • code/branches/pch/src/orxonox/overlays/notifications/NotificationQueue.cc

    r3110 r3144  
    3434#include "NotificationQueue.h"
    3535
    36 #include <OgreOverlayManager.h>
    37 #include <OgreTextAreaOverlayElement.h>
    38 #include <list>
    39 #include <iostream>
    4036#include <sstream>
    4137
    4238#include "core/CoreIncludes.h"
    4339#include "core/XMLPort.h"
    44 
    45 #include "Notification.h"
    4640#include "NotificationOverlay.h"
     41#include "NotificationManager.h"
    4742
    4843namespace orxonox
     
    6156    NotificationQueue::NotificationQueue(BaseObject* creator) : OverlayGroup(creator)
    6257    {
     58        RegisterObject(NotificationQueue);
    6359        this->initialize();
    6460    }
     
    8177    void NotificationQueue::initialize(void)
    8278    {
    83         RegisterObject(NotificationQueue);
    84 
    8579        this->size_ = 0;
    8680        this->tickTime_ = 0.0;
  • code/branches/pch/src/orxonox/overlays/notifications/NotificationQueue.h

    r2926 r3144  
    3737#include "OrxonoxPrereqs.h"
    3838
     39#include <ctime>
     40#include <map>
     41#include <set>
    3942#include <string>
    40 #include <set>
    41 #include <OgreOverlayManager.h>
    42 #include <OgreTextAreaOverlayElement.h>
    43 #include <OgrePanelOverlayElement.h>
    44 #include <map>
    45 #include <ctime>
    46 
     43
     44#include "util/Math.h"
     45#include "orxonox/objects/Tickable.h"
    4746#include "orxonox/overlays/OverlayGroup.h"
    48 #include "orxonox/objects/Tickable.h"
    49 
    50 #include "NotificationManager.h"
    5147
    5248namespace orxonox
Note: See TracChangeset for help on using the changeset viewer.