Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jun 20, 2009, 9:20:47 AM (15 years ago)
Author:
rgrieder
Message:

Merged pch branch back to trunk.

Location:
code/trunk
Files:
2 deleted
59 edited

Legend:

Unmodified
Added
Removed

  • code/trunk

  • code/trunk/src/orxonox/overlays/FadeoutText.cc

    r3110 r3196  
    3030
    3131#include <OgreTextAreaOverlayElement.h>
    32 
     32#include "util/Math.h"
    3333#include "core/CoreIncludes.h"
    3434#include "core/XMLPort.h"

  • code/trunk/src/orxonox/overlays/FadeoutText.h

    r3099 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "tools/Timer.h"
     35#include "interfaces/Tickable.h"
    3436#include "overlays/OverlayText.h"
    35 #include "objects/Tickable.h"
    36 #include "tools/Timer.h"
    3737
    3838namespace orxonox

  • code/trunk/src/orxonox/overlays/GUIOverlay.cc

    r3110 r3196  
    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/trunk/src/orxonox/overlays/GUIOverlay.h

    r3078 r3196  
    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/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

    r3110 r3196  
    215215            if (angle < 0.0)
    216216                angle = -angle;
    217             angle -= 180.0 * (int)(angle / 180.0);
     217            angle -= 180.0f * (int)(angle / 180.0);
    218218
    219219            // take the reverse if angle is about 90 degrees
    220220            float tempAspect;
    221             if (angle > 89.0 && angle < 91.0)
     221            if (angle > 89.0f && angle < 91.0f)
    222222            {
    223223                tempAspect = 1.0 / this->windowAspectRatio_;
    … …  
    231231            else
    232232            {
    233                 tempAspect = 1.0;
     233                tempAspect = 1.0f;
    234234                rotState_ = Inbetween;
    235235            }
    … …  
    238238            // magnitude of the width is about the magnitude of the height.
    239239            // Correctly we would have to take the square root of width*height
    240             this->sizeCorrection_.x = 2.0 / (tempAspect + 1.0);
     240            this->sizeCorrection_.x = 2.0f / (tempAspect + 1.0f);
    241241            this->sizeCorrection_.y = tempAspect * this->sizeCorrection_.x;
    242242        }

  • code/trunk/src/orxonox/overlays/OrxonoxOverlay.h

    r2993 r3196  
    3737#include "OrxonoxPrereqs.h"
    3838
    39 #include <OgrePrerequisites.h>
    40 #include "tools/WindowEventListener.h"
     39#include <string>
     40
    4141#include "util/Math.h"
     42#include "util/OgreForwardRefs.h"
    4243#include "core/BaseObject.h"
     44#include "interfaces/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/trunk/src/orxonox/overlays/OverlayGroup.cc

    r3110 r3196  
    3434#include "OverlayGroup.h"
    3535
    36 #include "util/Debug.h"
    3736#include "core/ConsoleCommand.h"
    3837#include "core/CoreIncludes.h"
    39 #include "core/Iterator.h"
    4038#include "core/XMLPort.h"
    4139#include "OrxonoxOverlay.h"

  • code/trunk/src/orxonox/overlays/OverlayGroup.h

    r2911 r3196  
    3838
    3939#include <set>
    40 #include <OgrePrerequisites.h>
     40#include "util/Math.h"
     41#include "util/OgreForwardRefs.h"
    4142#include "core/BaseObject.h"
    42 #include "util/Math.h"
    4343
    4444namespace orxonox

  • code/trunk/src/orxonox/overlays/OverlayText.cc

    r3110 r3196  
    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((int)Ogre::TextAreaOverlayElement::Left   == (int)OverlayText::Left);
     46    BOOST_STATIC_ASSERT((int)Ogre::TextAreaOverlayElement::Center == (int)OverlayText::Center);
     47    BOOST_STATIC_ASSERT((int)Ogre::TextAreaOverlayElement::Right  == (int)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(static_cast<Ogre::TextAreaOverlayElement::Alignment>(alignment));
     165    }
     166    OverlayText::Alignment OverlayText::getAlignment() const
     167    {
     168        return static_cast<OverlayText::Alignment>(this->text_->getAlignment());
     169    }
    122170}

  • code/trunk/src/orxonox/overlays/OverlayText.h

    r3099 r3196  
    3333
    3434#include <string>
    35 #include <OgrePrerequisites.h>
    36 #include <OgreTextAreaOverlayElement.h>
     35#include "util/Math.h"
     36#include "util/OgreForwardRefs.h"
    3737#include "OrxonoxOverlay.h"
    3838
    … …  
    4242    {
    4343    public:
     44        enum Alignment
     45        {
     46            Left,
     47            Right,
     48            Center
     49        };
     50
    4451        OverlayText(BaseObject* creator);
    4552        virtual ~OverlayText();
    … …  
    4754        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
    4855
    49         inline void setCaption(const std::string& caption) { this->text_->setCaption(caption); this->changedCaption(); }
    50         inline std::string getCaption() const              { return this->text_->getCaption(); }
     56        void setCaption(const std::string& caption);
     57        std::string getCaption() const;
    5158
    5259        void setFont(const std::string& font);
    53         inline const std::string& getFont() const { return this->text_->getFontName(); }
     60        const std::string& getFont() const;
    5461
    55         inline void setSpaceWidth(float width) { this->text_->setSpaceWidth(width); }
    56         inline float getSpaceWidth() const     { return this->text_->getSpaceWidth(); }
     62        void setSpaceWidth(float width);
     63        float getSpaceWidth() const;
    5764
    58         inline void setColour(const ColourValue& colour) { this->text_->setColour(colour); this->changedColour(); }
    59         inline const ColourValue& getColour() const      { return this->text_->getColour(); }
     65        void setColour(const ColourValue& colour);
     66        const ColourValue& getColour() const;
    6067
    61         inline void setAlignment(Ogre::TextAreaOverlayElement::Alignment alignment) { this->text_->setAlignment(alignment); }
    62         inline Ogre::TextAreaOverlayElement::Alignment getAlignment() const         { return this->text_->getAlignment(); }
     68        void setAlignment(OverlayText::Alignment alignment);
     69        OverlayText::Alignment getAlignment() const;
    6370
    6471        void setAlignmentString(const std::string& alignment);

  • code/trunk/src/orxonox/overlays/console/InGameConsole.cc

    r3110 r3196  
    3535#include <OgreOverlayManager.h>
    3636#include <OgreOverlayContainer.h>
     37#include <OgreBorderPanelOverlayElement.h>
     38#include <OgreTextAreaOverlayElement.h>
    3739#include <OgreFontManager.h>
    3840#include <OgreFont.h>
    … …  
    4042#include "util/Math.h"
    4143#include "util/Convert.h"
    42 #include "util/Debug.h"
     44#include "util/UTFStringConversions.h"
    4345#include "core/Clock.h"
    4446#include "core/CoreIncludes.h"
    … …  
    466468                {
    467469                    ++linesUsed;
    468                     this->consoleOverlayTextAreas_[index]->setCaption(convert2UTF(output.substr(0, this->maxCharsPerLine_)));
     470                    this->consoleOverlayTextAreas_[index]->setCaption(multi_cast<Ogre::UTFString>(output.substr(0, this->maxCharsPerLine_)));
    469471                    output.erase(0, this->maxCharsPerLine_);
    470472                    output.insert(0, 1, ' ');
    … …  
    473475                    this->colourLine(level, index);
    474476                }
    475                 this->consoleOverlayTextAreas_[index]->setCaption(convert2UTF(output));
     477                this->consoleOverlayTextAreas_[index]->setCaption(multi_cast<Ogre::UTFString>(output));
    476478                this->displayedText_ = output;
    477479                this->numLinesShifted_ = linesUsed;
    … …  
    491493                  this->inputWindowStart_ = 0;
    492494                this->displayedText_ = output;
    493                 this->consoleOverlayTextAreas_[index]->setCaption(convert2UTF(output));
     495                this->consoleOverlayTextAreas_[index]->setCaption(multi_cast<Ogre::UTFString>(output));
    494496            }
    495497        }
    … …  
    606608        InGameConsole::getInstance().deactivate();
    607609    }
    608 
    609     /**
    610         @brief Converts a string into an Ogre::UTFString.
    611         @param s The string to convert
    612         @return The converted string
    613     */
    614     /*static*/ Ogre::UTFString InGameConsole::convert2UTF(const std::string& text)
    615     {
    616         Ogre::UTFString utf;
    617         Ogre::UTFString::code_point cp;
    618         for (unsigned int i = 0; i < text.size(); ++i)
    619         {
    620           cp = text[i];
    621           cp &= 0xFF;
    622           utf.append(1, cp);
    623         }
    624         return utf;
    625     }
    626610}

  • code/trunk/src/orxonox/overlays/console/InGameConsole.h

    r2896 r3196  
    3232
    3333#include "OrxonoxPrereqs.h"
    34 #include <OgrePrerequisites.h>
    35 #include <OgreBorderPanelOverlayElement.h>
    36 #include <OgreTextAreaOverlayElement.h>
    3734
     35#include <string>
     36#include "util/OgreForwardRefs.h"
    3837#include "core/Shell.h"
    39 #include "core/OrxonoxClass.h"
    40 #include "tools/WindowEventListener.h"
    41 
     38#include "interfaces/WindowEventListener.h"
    4239
    4340namespace orxonox
    4441{
    45     class _OrxonoxExport InGameConsole : virtual public OrxonoxClass, public ShellListener, public WindowEventListener
     42    class _OrxonoxExport InGameConsole : public ShellListener, public WindowEventListener
    4643    {
    4744    public: // functions
    … …  
    6057        static void openConsole();
    6158        static void closeConsole();
    62 
    63         static Ogre::UTFString convert2UTF(const std::string& text);
    6459
    6560    private: // functions

  • code/trunk/src/orxonox/overlays/debug/DebugFPSText.cc

    r3110 r3196  
    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/trunk/src/orxonox/overlays/debug/DebugFPSText.h

    r2087 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "interfaces/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/trunk/src/orxonox/overlays/debug/DebugRTRText.cc

    r3110 r3196  
    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/trunk/src/orxonox/overlays/debug/DebugRTRText.h

    r2087 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "interfaces/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/trunk/src/orxonox/overlays/hud/AnnounceMessage.h

    r3099 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "interfaces/GametypeMessageListener.h"
    3435#include "overlays/FadeoutText.h"
    35 #include "objects/GametypeMessageListener.h"
    3636
    3737namespace orxonox

  • code/trunk/src/orxonox/overlays/hud/ChatOverlay.cc

    r3110 r3196  
    2929#include "ChatOverlay.h"
    3030
     31#include <string>
    3132#include <OgreTextAreaOverlayElement.h>
    3233
     34#include "util/Convert.h"
     35#include "util/UTFStringConversions.h"
    3336#include "core/CoreIncludes.h"
    3437#include "core/ConfigValueIncludes.h"
    3538#include "core/Executor.h"
    3639
    37 #include "network/ClientInformation.h"
    38 
     40#include "tools/Timer.h"
     41#include "objects/infos/PlayerInfo.h"
    3942#include "PlayerManager.h"
    40 #include "objects/infos/PlayerInfo.h"
    41 #include "overlays/console/InGameConsole.h"
    42 #include "tools/Timer.h"
    43 
    44 #include "util/Convert.h"
    4543
    4644namespace orxonox
    … …  
    8684        }
    8785
    88         this->messages_.push_back(InGameConsole::convert2UTF(text));
     86        this->messages_.push_back(multi_cast<Ogre::UTFString>(text));
    8987        COUT(0) << "Chat: " << text << std::endl;
    9088

  • code/trunk/src/orxonox/overlays/hud/ChatOverlay.h

    r2171 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
    34 #include <OgreTextAreaOverlayElement.h>
     34#include <list>
     35#include <OgreUTFString.h>
    3536
    3637#include "network/ChatListener.h"
    … …  
    4344        public:
    4445            ChatOverlay(BaseObject* creator);
    45             ~ChatOverlay();
     46            virtual ~ChatOverlay();
    4647
    4748            void setConfigValues();

  • code/trunk/src/orxonox/overlays/hud/DeathMessage.h

    r3099 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "interfaces/GametypeMessageListener.h"
    3435#include "overlays/FadeoutText.h"
    35 #include "objects/GametypeMessageListener.h"
    3636
    3737namespace orxonox

  • code/trunk/src/orxonox/overlays/hud/GametypeStatus.cc

    r3110 r3196  
    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/trunk/src/orxonox/overlays/hud/GametypeStatus.h

    r2973 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "interfaces/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/trunk/src/orxonox/overlays/hud/HUDBar.cc

    r3110 r3196  
    3434#include <OgreMaterialManager.h>
    3535#include <OgreTechnique.h>
     36#include <OgrePass.h>
    3637#include <OgrePanelOverlayElement.h>
    3738
    … …  
    7778        this->textureUnitState_->setTextureName("bar2.tga");
    7879        // use the default colour
    79         this->textureUnitState_->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, ColourValue(0.2, 0.7, 0.2));
     80        this->textureUnitState_->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, ColourValue(0.2f, 0.7f, 0.2f));
    8081
    8182        this->bar_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()

  • code/trunk/src/orxonox/overlays/hud/HUDBar.h

    r2662 r3196  
    3535
    3636#include <map>
    37 #include <OgrePrerequisites.h>
     37#include <vector>
     38
    3839#include "util/Math.h"
     40#include "util/OgreForwardRefs.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/trunk/src/orxonox/overlays/hud/HUDHealthBar.cc

    r3110 r3196  
    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/trunk/src/orxonox/overlays/hud/HUDHealthBar.h

    r2662 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "util/Math.h"
     35#include "interfaces/Tickable.h"
     36#include "overlays/OverlayText.h"
    3437#include "HUDBar.h"
    35 #include "objects/Tickable.h"
    36 #include "overlays/OverlayText.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/trunk/src/orxonox/overlays/hud/HUDNavigation.cc

    r3110 r3196  
    2929#include "HUDNavigation.h"
    3030
     31#include <string>
    3132#include <OgreOverlayManager.h>
    3233#include <OgreTextAreaOverlayElement.h>
    … …  
    3637#include "util/String.h"
    3738#include "util/Convert.h"
    38 #include "core/ConsoleCommand.h"
    3939#include "core/CoreIncludes.h"
    4040#include "core/XMLPort.h"

  • code/trunk/src/orxonox/overlays/hud/HUDNavigation.h

    r2087 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
    34 #include <OgrePrerequisites.h>
     34#include "util/OgreForwardRefs.h"
     35#include "interfaces/Tickable.h"
    3536#include "overlays/OrxonoxOverlay.h"
    36 #include "objects/Tickable.h"
    3737
    3838namespace orxonox
    … …  
    4242    public:
    4343        HUDNavigation(BaseObject* creator);
    44         ~HUDNavigation();
     44        virtual ~HUDNavigation();
    4545
    4646        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);

  • code/trunk/src/orxonox/overlays/hud/HUDRadar.cc

    r3110 r3196  
    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/trunk/src/orxonox/overlays/hud/HUDRadar.h

    r2662 r3196  
    3333#include "OrxonoxPrereqs.h"
    3434
     35#include <map>
    3536#include <vector>
    36 #include <map>
    37 #include <OgrePrerequisites.h>
     37
     38#include "util/OgreForwardRefs.h"
     39#include "interfaces/RadarListener.h"
     40#include "interfaces/RadarViewable.h"
    3841#include "overlays/OrxonoxOverlay.h"
    39 #include "objects/RadarListener.h"
    40 #include "objects/RadarViewable.h"
    4142
    4243namespace orxonox
    … …  
    4647    public:
    4748        HUDRadar(BaseObject* creator);
    48         ~HUDRadar();
     49        virtual ~HUDRadar();
    4950
    5051        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);

  • code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.cc

    r3110 r3196  
    2929
    3030#include "HUDSpeedBar.h"
     31
    3132#include "core/CoreIncludes.h"
    3233#include "objects/worldentities/pawns/SpaceShip.h"

  • code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.h

    r2662 r3196  
    3333#include "OrxonoxPrereqs.h"
    3434
     35#include "interfaces/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/trunk/src/orxonox/overlays/hud/HUDTimer.cc

    r3110 r3196  
    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/trunk/src/orxonox/overlays/hud/HUDTimer.h

    r3033 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "interfaces/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/trunk/src/orxonox/overlays/hud/KillMessage.h

    r3099 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "interfaces/GametypeMessageListener.h"
    3435#include "overlays/FadeoutText.h"
    35 #include "objects/GametypeMessageListener.h"
    3636
    3737namespace orxonox

  • code/trunk/src/orxonox/overlays/hud/PongScore.cc

    r3110 r3196  
    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/trunk/src/orxonox/overlays/hud/PongScore.h

    r3078 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "interfaces/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/trunk/src/orxonox/overlays/hud/TeamBaseMatchScore.cc

    r3110 r3196  
    2828
    2929#include "TeamBaseMatchScore.h"
    30 
    31 #include <OgreTextAreaOverlayElement.h>
    3230
    3331#include "core/CoreIncludes.h"

  • code/trunk/src/orxonox/overlays/hud/TeamBaseMatchScore.h

    r3104 r3196  
    3232#include "OrxonoxPrereqs.h"
    3333
     34#include "interfaces/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/trunk/src/orxonox/overlays/hud/UnderAttackHealthBar.cc

    r3110 r3196  
    4747        this->text_ = new OverlayText(this);
    4848        this->text_->setFont("Monofur");
    49         this->text_->setTextSize(0.04);
     49        this->text_->setTextSize(0.04f);
    5050        this->text_->setAlignmentString("center");
    5151        this->text_->setColour(ColourValue::White);

  • code/trunk/src/orxonox/overlays/hud/UnderAttackHealthBar.h

    r3104 r3196  
    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/trunk/src/orxonox/overlays/map/Map.cc

    r3110 r3196  
    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 <OgreEntity.h>
     34#include <OgreHardwarePixelBuffer.h>
     35#include <OgreMaterialManager.h>
     36#include <OgreMovablePlane.h>
     37#include <OgreOverlay.h>
     38#include <OgreOverlayContainer.h>
     39#include <OgreOverlayManager.h>
     40#include <OgrePass.h>
     41#include <OgreRenderTexture.h>
     42#include <OgreResourceGroupManager.h>
     43#include <OgreRoot.h>
    3044#include <OgreSceneManager.h>
    3145#include <OgreSceneNode.h>
    32 #include <OgreEntity.h>
    33 #include <OgreNode.h>
    34 
    35 
    36 #include <OgreRenderWindow.h>
    37 #include <OgreRenderTexture.h>
     46#include <OgreTechnique.h>
    3847#include <OgreTexture.h>
     48#include <OgreTextureManager.h>
    3949#include <OgreViewport.h>
    4050
    41 #include <OgreMaterialManager.h>
    42 #include <OgreRoot.h>
    43 #include <OgreHardwarePixelBuffer.h>
     51#include "core/ConsoleCommand.h"
     52#include "core/CoreIncludes.h"
     53#include "core/XMLPort.h"
     54#include "interfaces/RadarViewable.h"
     55#include "objects/Scene.h"
     56#include "objects/controllers/HumanController.h"
     57#include "objects/worldentities/CameraPosition.h"
    4458#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>
    52 #include "core/CoreIncludes.h"
    53 #include "core/ConfigValueIncludes.h"
    54 #include "core/ConsoleCommand.h"
    55 #include "objects/Scene.h"
    56 #include "objects/RadarViewable.h"
    57 #include "objects/controllers/HumanController.h"
    5859
    5960 namespace orxonox
    … …  
    264265    }
    265266
    266     Ogre::MaterialPtr Map::createRenderCamera(Ogre::Camera * cam, std::string matName)
     267    Ogre::MaterialPtr Map::createRenderCamera(Ogre::Camera * cam, const std::string& matName)
    267268    {
    268269        Ogre::TexturePtr rttTex = Ogre::TextureManager::getSingleton().createManual(matName+"_tex", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 512, 512, 0, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET);
    … …  
    400401    }
    401402
     403    // HACK!
     404    void Map::hackDestroyMap()
     405    {
     406        Map::OverlayMaterial_.setNull();
     407    }
     408
    402409    void Map::tick(float dt)
    403410    {

  • code/trunk/src/orxonox/overlays/map/Map.h

    r3101 r3196  
    2525 */
    2626
    27 #ifndef _MAP_H__
    28 #define _MAP_H__
     27#ifndef _Map_H__
     28#define _Map_H__
    2929
    30 #include <string>
    3130#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>
    4131
    42 #include <OgreBorderPanelOverlayElement.h>
    43 #include <OgreTextAreaOverlayElement.h>
     32#include <OgreMaterial.h>
    4433
     34#include "util/UtilPrereqs.h"
     35#include "interfaces/Tickable.h"
    4536#include "overlays/OrxonoxOverlay.h"
    46 #include "objects/Tickable.h"
    47 
    48 
    4937
    5038namespace orxonox
    … …  
    5543    public: // functions
    5644        Map(BaseObject* creator);
    57         ~Map();
     45        virtual ~Map();
    5846
    5947        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
    … …  
    6149        virtual void changedOwner();
    6250
    63         static Ogre::MaterialPtr createRenderCamera(Ogre::Camera * cam, std::string matName);
     51        static Ogre::MaterialPtr createRenderCamera(Ogre::Camera * cam, const std::string& matName);
    6452
    6553        static void openMap();
     54        // HACK!
     55        static void hackDestroyMap();
    6656
    6757//Not yet implemented
    … …  
    126116}
    127117
    128 #endif /* _MAP_H__ */
     118#endif /* _Map_H__ */

  • code/trunk/src/orxonox/overlays/notifications/Notification.cc

    r3110 r3196  
    2828
    2929/**
    30     @file Notification.cc
     30    @file
    3131    @brief Implementation of the Notification class.
    3232*/
    … …  
    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/trunk/src/orxonox/overlays/notifications/Notification.h

    r3034 r3196  
    2828
    2929/**
    30     @file Notification.h
     30    @file
    3131    @brief Definition of the Notification class.
    3232*/
    … …  
    3838
    3939#include <string>
    40 
    4140#include "core/BaseObject.h"
    4241

  • code/trunk/src/orxonox/overlays/notifications/NotificationManager.cc

    r3110 r3196  
    2828
    2929/**
    30     @file NotificationManager.cc
     30    @file
    3131    @brief Implementation of the NotificationManager class.
    3232*/
    … …  
    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/trunk/src/orxonox/overlays/notifications/NotificationManager.h

    r3034 r3196  
    2828
    2929/**
    30     @file NotificationManager.h
     30    @file
    3131    @brief Definition of the NotificationManager class.
    3232*/
    … …  
    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/trunk/src/orxonox/overlays/notifications/NotificationOverlay.cc

    r3110 r3196  
    2828
    2929/**
    30     @file NotificationOverlay.cc
     30    @file
    3131    @brief Implementation of the NotificationOverlay class.
    3232*/
    … …  
    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    }
    … …  
    133127        Clips the input message so that it meets the requirements for the maximal length of Notifications given by the NotificationQueue.
    134128    */
    135     const std::string NotificationOverlay::clipMessage(const std::string & message)
     129    std::string NotificationOverlay::clipMessage(const std::string & message)
    136130    {
    137131        if(message.length() <= (unsigned int)this->queue_->getNotificationLength()) //!< If the message is not too long.

  • code/trunk/src/orxonox/overlays/notifications/NotificationOverlay.h

    r3078 r3196  
    2828
    2929/**
    30     @file NotificationOverlay.h
     30    @file
    3131    @brief Definition of the NotificationOverlay class.
    3232*/
    … …  
    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
    … …  
    7268       
    7369        protected:
    74             const std::string clipMessage(const std::string & message); //!< Clips the input message if too long.
     70            std::string clipMessage(const std::string & message); //!< Clips the input message if too long.
    7571
    7672        private:

  • code/trunk/src/orxonox/overlays/notifications/NotificationQueue.cc

    r3110 r3196  
    2828
    2929/**
    30     @file NotificationQueue.cc
     30    @file
    3131    @brief Implementation of the NotificationQueue class.
    3232*/
    … …  
    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
    … …  
    5348    const std::string NotificationQueue::DEFAULT_FONT = "VeraMono";
    5449    const Vector2 NotificationQueue::DEFAULT_POSITION = Vector2(0.0,0.0);
    55     const float NotificationQueue::DEFAULT_FONT_SIZE  = 0.025;
     50    const float NotificationQueue::DEFAULT_FONT_SIZE  = 0.025f;
    5651
    5752    /**
    … …  
    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/trunk/src/orxonox/overlays/notifications/NotificationQueue.h

    r2926 r3196  
    2828
    2929/**
    30     @file NotificationQueue.h
     30    @file
    3131    @brief Definition of the NotificationQueue class.
    3232*/
    … …  
    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 
    47 #include "orxonox/overlays/OverlayGroup.h"
    48 #include "orxonox/objects/Tickable.h"
    49 
    50 #include "NotificationManager.h"
     43
     44#include "util/Math.h"
     45#include "interfaces/Tickable.h"
     46#include "overlays/OverlayGroup.h"
    5147
    5248namespace orxonox

  • code/trunk/src/orxonox/overlays/stats/CMakeLists.txt

    r2710 r3196  
    33  Scoreboard.cc
    44  Stats.cc
    5   StatsTest.cc
    65)

  • code/trunk/src/orxonox/overlays/stats/CreateLines.cc

    r3110 r3196  
    2626
    2727#include "CreateLines.h"
    28 
    29 #include <string>
    30 #include <OgreOverlay.h>
    31 #include <OgreOverlayElement.h>
    32 #include <OgreOverlayManager.h>
    33 #include <OgreOverlayContainer.h>
    34 
    35 #include "util/Convert.h"
    36 #include "util/Debug.h"
    37 #include "core/CoreIncludes.h"
    38 #include "core/ConfigValueIncludes.h"
    3928
    4029#include "overlays/OverlayText.h"

  • code/trunk/src/orxonox/overlays/stats/CreateLines.h

    r2662 r3196  
    2828#define _CreateLines_H__
    2929
    30 
    3130#include "OrxonoxPrereqs.h"
    32 #include <OgrePrerequisites.h>
    33 #include <OgreBorderPanelOverlayElement.h>
    34 #include <OgreTextAreaOverlayElement.h>
    35 
    36 #include "overlays/OrxonoxOverlay.h"
    37 #include "objects/Tickable.h"
    38 
    3931
    4032namespace orxonox

  • code/trunk/src/orxonox/overlays/stats/Scoreboard.cc

    r3110 r3196  
    2727#include "Scoreboard.h"
    2828
    29 #include <string>
    30 #include <OgreOverlay.h>
    31 #include <OgreOverlayElement.h>
    32 #include <OgreOverlayManager.h>
    33 #include <OgreOverlayContainer.h>
    34 
    3529#include "util/Convert.h"
    36 #include "util/Debug.h"
    3730#include "core/CoreIncludes.h"
    38 #include "core/ConfigValueIncludes.h"
    3931#include "objects/gametypes/Gametype.h"
    4032#include "objects/infos/PlayerInfo.h"
    … …  
    10193        for (std::map<PlayerInfo*, Player>::const_iterator it = playerList.begin(); it != playerList.end(); ++it)
    10294        {
    103             this->lines_[index]->setPlayerName(omni_cast<std::string>(it->first->getName()));
    104             this->lines_[index]->setScore(omni_cast<std::string>(it->second.frags_));
    105             this->lines_[index]->setDeaths(omni_cast<std::string>(it->second.killed_));
     95            this->lines_[index]->setPlayerName(multi_cast<std::string>(it->first->getName()));
     96            this->lines_[index]->setScore(multi_cast<std::string>(it->second.frags_));
     97            this->lines_[index]->setDeaths(multi_cast<std::string>(it->second.killed_));
    10698            index++;
    10799        }

  • code/trunk/src/orxonox/overlays/stats/Scoreboard.h

    r2662 r3196  
    3030
    3131#include "OrxonoxPrereqs.h"
    32 #include <OgrePrerequisites.h>
    33 #include <OgreBorderPanelOverlayElement.h>
    34 #include <OgreTextAreaOverlayElement.h>
    3532
     33#include <string>
     34#include <vector>
     35#include "interfaces/Tickable.h"
    3636#include "overlays/OrxonoxOverlay.h"
    37 #include "objects/Tickable.h"
    38 
    3937
    4038namespace orxonox
    … …  
    4240    class _OrxonoxExport Scoreboard : public OrxonoxOverlay, public Tickable
    4341    {
    44 
    4542    public: // functions
    4643        Scoreboard(BaseObject* creator);

  • code/trunk/src/orxonox/overlays/stats/Stats.cc

    r3110 r3196  
    3030
    3131#include <string>
    32 #include <OgreOverlay.h>
    33 #include <OgreOverlayElement.h>
    3432#include <OgreOverlayManager.h>
    35 #include <OgreOverlayContainer.h>
     33#include <OgreBorderPanelOverlayElement.h>
    3634
    37 #include "util/Convert.h"
    38 #include "util/Debug.h"
     35#include "util/String.h"
    3936#include "core/CoreIncludes.h"
    4037#include "core/ConfigValueIncludes.h"

  • code/trunk/src/orxonox/overlays/stats/Stats.h

    r2662 r3196  
    3030#define _Stats_H__
    3131
     32#include "OrxonoxPrereqs.h"
    3233
    33 #include "OrxonoxPrereqs.h"
    34 #include <OgrePrerequisites.h>
    35 #include <OgreBorderPanelOverlayElement.h>
    36 #include <OgreTextAreaOverlayElement.h>
    37 
     34#include "util/OgreForwardRefs.h"
     35#include "interfaces/Tickable.h"
    3836#include "overlays/OrxonoxOverlay.h"
    39 #include "objects/Tickable.h"
    40 
    4137
    4238namespace orxonox
Note: See TracChangeset for help on using the changeset viewer.