Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/archive/waypoints/src/orxonox/overlays/OrxonoxOverlay.h @ 12389

Last change on this file since 12389 was 9159, checked in by scmoritz, 13 years ago

3DScene added. creation of the arrow doesnt work.

  • Property svn:eol-style set to native
File size: 9.8 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Reto Grieder
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30@file
31@brief Declaration of the OrxonoxOverlay class.
32*/
33
34#ifndef _OrxonoxOverlay_H__
35#define _OrxonoxOverlay_H__
36
37#include "OrxonoxPrereqs.h"
38
39#include <string>
40
41#include "util/Math.h"
42#include "util/OgreForwardRefs.h"
43#include "core/BaseObject.h"
44#include "core/Super.h"
45#include "core/WindowEventListener.h"
46
47
48namespace orxonox
49{
50    /**
51    @brief
52        Base class to display content directly onto the screen.
53        This is merely a wrapper of the Ogre::Overlay to implement more features and integrate it
54        in our class hierarchy for xml loading and config values.
55        The mentioned features are:
56        - Automatic positioning depending on the scale and the rotation angle.
57          You can specify a "pick point" relative to the overlay itself. This point will always be exactly
58          at the position (position_) of the overlay. That allows for margin/corner aligment.
59          It even works when a rotation angle is applied.
60        - Virtual methods for changedVisibilty() (BaseObject), angleChanged(), sizeCorrectionChanged(),
61          sizeChanged() and positionChanged(), that can be overridden by any derivative. This enables for
62          custom configurability of the size, position and rotation attributes. For intance, the HUDNavigation
63          should behave differently to sizeChanged() than a standard overlay.
64        - Console commands for scale, rotate and scroll (accessed by name)
65        - Standard Ogre::PanelOverlayElement for a background image (class doesn't have to be derived
66          only for displaying a picture).
67        - Reacts to changes of the window aspect
68        - Last but not least: On demand you can tell the overlay to automatically resale to correct for
69          aspect distortion. E.g. if you play 1024x768 you wouldn't want a round object to be oval.
70          Remark: This can (due to the Ogre::Overlay transformation order) only work for angle that are
71                  multiples of 90 degrees. But it's only a small drawback.
72    */
73    class _OrxonoxExport OrxonoxOverlay : public BaseObject, public WindowEventListener
74    {
75    public:
76        /**
77        @brief
78            Describes the rotational state of a an overlay.
79            Horizontal means 0/180 degrees, Vertical is 90/270 degrees
80            and in between is everything else.
81        */
82        enum RotationState
83        {
84            Horizontal,
85            Vertical,
86            Inbetween
87        };
88
89    public:
90        OrxonoxOverlay(BaseObject* creator);
91        virtual ~OrxonoxOverlay();
92
93        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
94
95        virtual void changedName();
96
97        //! Shows the overlay with an detour to BaseObject::visibility_
98        void show() { this->setVisible(true); }
99        //! Hides the overlay with an detour to BaseObject::visibility_
100        void hide() { this->setVisible(false); }
101
102        /** Sets whether the aspect of the overlay is corrected.
103            This is for instance useful for round objects that should stay round no matter
104            what the screen resolution is. */
105        void setAspectCorrection(bool val)        { this->bCorrectAspect_ = val; this->sizeCorrectionChanged(); }
106        //! Returns whether the window aspect is corrected
107        bool getAspectCorrection() const          { return this->bCorrectAspect_; }
108
109        //! Sets the position of this overlay on the screen.
110        void setPosition(Vector2 pos)             { this->position_ = pos; this->positionChanged(); }
111
112        //! Returns the current position on the screen.
113        const Vector2& getPosition() const        { return this->position_; }
114
115        //! Scrolls the overlay. @param offset The offset given.
116        void scroll(const Vector2& offset)        { this->position_ += offset; this->positionChanged(); }
117
118        /** Sets the point in the overlay where to pick it when translating.
119            For instance setting it to (1.0,1.0) means that the lower right corner of the
120            overlay will be put at position_.
121            This primarily helps aligning an overlay to any corner/margin on the screen. */
122        void setPickPoint(const Vector2& position){ this->pickPoint_ = position; this->positionChanged(); }
123
124        //! Gets the pick point of this overlay. @see setPickPoint()
125        const Vector2& getPickPoint() const       { return this->pickPoint_; }
126
127        //! Sets the rotation angle applied to this overlay in degrees.
128        void setRotation(const Degree& angle)     { this->angle_ = angle; this->angleChanged(); }
129
130        //! Gets the rotation angle applied to this overlay in degrees.
131        const Degree& getRotation() const         { return this->angle_; }
132
133        //! Rotates the overlay by angle degrees.
134        void rotate(const Degree& angle)          { this->angle_ += angle; this->angleChanged(); }
135
136        //! Sets the size of this overlay.
137        void setSize(const Vector2& size)         { this->size_ = size; this->sizeChanged(); }
138
139        //! Gets the current size that was set (uncorrected)
140        const Vector2& getSize() const            { return this->size_; }
141
142        //! Gets the actual size of the overlay on the screen (corrected)
143        Vector2 getActualSize() const             { return this->size_ * this->sizeCorrection_; }
144
145        //! Gets the current size correction (default: 1.0, 1.0)
146        const Vector2& getSizeCorrection() const  { return this->sizeCorrection_; }
147
148        //! Scales the overlay by scale.
149        void scale(const Vector2& scale)          { this->size_ *= scale; this->sizeChanged(); }
150
151        //! ConsoleCommand: Accesses the overlay by its name and scales it.
152        static void scaleOverlay(const std::string& name, float scale);
153        //! ConsoleCommand: Accesses the overlay by its name and scrolls it.
154        static void scrollOverlay(const std::string& name, const Vector2& scroll);
155        static void toggleVisibility(const std::string& name);
156        static void showOverlay(const std::string& name);
157        //! ConsoleCommand: Accesses the overlay by its name and rotates it.
158        static void rotateOverlay(const std::string& name, const Degree& angle);
159
160        void setBackgroundMaterial(const std::string& material);
161        const std::string& getBackgroundMaterial() const;
162
163        void setBackgroundTexture(const std::string& texture);
164        const std::string& getBackgroundTexture() const;
165
166        void setBackgroundAlpha(float alpha);
167
168        void setBackgroundColour(ColourValue colour);
169
170        virtual void changedVisibility();
171
172        inline void setOwner(BaseObject* owner)
173        {
174            if (this->owner_ != owner)
175            {
176                this->owner_ = owner;
177                this->changedOwner();
178            }
179        }
180        inline BaseObject* getOwner() const
181            { return this->owner_; }
182        virtual void changedOwner() {}
183
184        void setOverlayGroup(OverlayGroup* group);
185        inline OverlayGroup* getOverlayGroup() const
186            { return this->group_; }
187        virtual void changedOverlayGroup()
188            { this->changedVisibility(); }
189        void add3DMesh(Ogre::Entity* entity);
190
191
192    protected:
193        virtual void angleChanged();
194        virtual void sizeCorrectionChanged();
195        virtual void sizeChanged();
196        virtual void positionChanged();
197
198        Ogre::Overlay* overlay_;                   //!< The overlay the entire class is about.
199        Ogre::PanelOverlayElement* background_;    //!< Background image (blank per default).
200        Ogre::SceneNode* overlay3d_;                               //!< The scene where one can add 3D objects to the overlay
201
202        float windowAspectRatio_;                  //!< Screen.width / screen.height
203        bool bCorrectAspect_;                      //!< Whether or not to correct the size. @see setAspectCorrection()
204        Vector2 size_;                             //!< Internal size of the overlay.
205        Vector2 sizeCorrection_;                   //!< Value to correct the size because of the window aspect.
206        Vector2 position_;                         //!< Position of the pickPoint on the screen.
207        Vector2 pickPoint_;                        //!< Point on the overlay to pick when translating
208        Degree angle_;                             //!< Rotation angle of the overlay
209        RotationState rotState_;                   //!< horizontal, vertical or inbetween
210
211    private:
212        void windowResized(unsigned int newWidth, unsigned int newHeight);
213
214        static unsigned int hudOverlayCounter_s;   //!< Static counter for hud elements
215        /** Contains all the overlays in a map for quick access via console commands.
216            We could also use the ObjectList, but that doesn't guarantee XMLPort(.) was called and is slower. */
217        static std::map<std::string, OrxonoxOverlay*> overlays_s;
218        BaseObject* owner_;
219        OverlayGroup* group_;
220        Ogre::Pass* backgroundAlphaPass_;
221
222  };
223
224  SUPER_FUNCTION(6, OrxonoxOverlay, changedOwner, false);
225  SUPER_FUNCTION(7, OrxonoxOverlay, changedOverlayGroup, false);
226}
227
228#endif /* _OrxonoxOverlay_H__ */
Note: See TracBrowser for help on using the repository browser.