Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc @ 2059

Last change on this file since 2059 was 1755, checked in by rgrieder, 16 years ago

merged gui back to trunk.
update the media repository!

  • Property svn:eol-style set to native
File size: 10.9 KB
RevLine 
[1588]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
[1622]29/**
30@file
31@brief Definition of the OrxonoxOverlay class.
32*/
33
[1588]34#include "OrxonoxStableHeaders.h"
[1601]35#include "OrxonoxOverlay.h"
[1588]36
[1615]37#include <cmath>
[1622]38#include <OgreOverlay.h>
[1588]39#include <OgreOverlayManager.h>
[1614]40#include <OgrePanelOverlayElement.h>
[1588]41#include "util/Convert.h"
[1615]42#include "util/String.h"
[1588]43#include "core/CoreIncludes.h"
[1616]44#include "core/XMLPort.h"
45#include "core/ConsoleCommand.h"
[1590]46#include "GraphicsEngine.h"
[1588]47
48namespace orxonox
49{
[1615]50    unsigned int OrxonoxOverlay::hudOverlayCounter_s = 0;
51    std::map<std::string, OrxonoxOverlay*> OrxonoxOverlay::overlays_s;
[1588]52
[1747]53    SetConsoleCommand(OrxonoxOverlay, scaleOverlay, false).accessLevel(AccessLevel::User);
54    SetConsoleCommand(OrxonoxOverlay, scrollOverlay, false).accessLevel(AccessLevel::User);
55    SetConsoleCommand(OrxonoxOverlay, rotateOverlay, false).accessLevel(AccessLevel::User);
[1588]56
[1615]57    OrxonoxOverlay::OrxonoxOverlay()
58        : overlay_(0)
59        , background_(0)
60    {
61        RegisterObject(OrxonoxOverlay);
62    }
[1614]63
[1622]64    /**
65    @brief
66        Make sure everything gets removed/destroyed.
67    @remark
68        We assume that the Ogre::OverlayManager exists (there is an assert in Ogre for that!)
69    */
[1615]70    OrxonoxOverlay::~OrxonoxOverlay()
71    {
[1622]72        // erase ourself from the map with all overlays
[1615]73        std::map<std::string, OrxonoxOverlay*>::iterator it = overlays_s.find(this->getName());
74        if (it != overlays_s.end())
75            overlays_s.erase(it);
[1622]76
77        if (this->background_)
78            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->background_);
79        if (this->overlay_)
80            Ogre::OverlayManager::getSingleton().destroy(this->overlay_);
[1615]81    }
82
[1622]83    /**
84    @brief
85        Loads the OrxonoxOverlay.
[1747]86
[1622]87        This has to be called before usage, otherwise strange behaviour is
88        guaranteed! (there should be no segfaults however).
89    @copydoc
90        BaseObject::XMLPort()
91    */
[1615]92    void OrxonoxOverlay::XMLPort(Element& xmlElement, XMLPort::Mode mode)
[1590]93    {
[1747]94        SUPER(OrxonoxOverlay, XMLPort, xmlElement, mode);
[1588]95
[1615]96        if (mode == XMLPort::LoadObject)
97        {
[1622]98            // add this overlay to the static map of OrxonoxOverlays
[1615]99            if (overlays_s.find(this->getName()) != overlays_s.end())
100            {
101                COUT(1) << "Overlay names should be unique or you cannnot access them via console." << std::endl;
102            }
103            overlays_s[this->getName()] = this;
[1614]104
[1622]105            // create the Ogre::Overlay
[1615]106            overlay_ = Ogre::OverlayManager::getSingleton().create("OrxonoxOverlay_overlay_"
107                + convertToString(hudOverlayCounter_s++));
[1590]108
[1622]109            // create background panel (can be used to show any picture)
[1615]110            this->background_ = static_cast<Ogre::PanelOverlayElement*>(
111                Ogre::OverlayManager::getSingleton().createOverlayElement("Panel",
112                "OrxonoxOverlay_background_" + convertToString(hudOverlayCounter_s++)));
113            this->overlay_->add2D(this->background_);
[1588]114
[1627]115            // We'll have to get the aspect ratio manually for the first time. Afterwards windowResized() gets
[1622]116            // called automatically by the GraphicsEngine.
[1755]117            this->windowResized(GraphicsEngine::getInstance().getWindowWidth(),
118                GraphicsEngine::getInstance().getWindowHeight());
[1595]119
[1627]120            this->changedVisibility();
[1615]121        }
[1627]122
123        XMLPortParam(OrxonoxOverlay, "size",      setSize,      getSize,      xmlElement, mode)
[1633]124            .defaultValues(Vector2(1.0f, 1.0f));
[1627]125        XMLPortParam(OrxonoxOverlay, "pickPoint", setPickPoint, getPickPoint, xmlElement, mode)
126            .defaultValues(Vector2(0.0f, 0.0f));
127        XMLPortParam(OrxonoxOverlay, "position",  setPosition,  getPosition,  xmlElement, mode)
128            .defaultValues(Vector2(0.0f, 0.0f));
129        XMLPortParam(OrxonoxOverlay, "rotation",  setRotation,  getRotation,  xmlElement, mode)
130            .defaultValues(0.0f);
131        XMLPortParam(OrxonoxOverlay, "correctAspect", setAspectCorrection,   getAspectCorrection,   xmlElement, mode)
132            .defaultValues(true);
133        XMLPortParam(OrxonoxOverlay, "background",    setBackgroundMaterial, getBackgroundMaterial, xmlElement, mode)
134            .defaultValues("");
[1590]135    }
[1588]136
[1622]137    //! Only sets the background material name if not ""
[1615]138    void OrxonoxOverlay::setBackgroundMaterial(const std::string& material)
139    {
140        if (this->background_ && material != "")
141            this->background_->setMaterialName(material);
142    }
[1588]143
[1622]144    //! Returns the the material name of the background
[1615]145    const std::string& OrxonoxOverlay::getBackgroundMaterial() const
146    {
147        if (this->background_)
148            return this->background_->getMaterialName();
149        else
150            return blankString;
151    }
[1614]152
[1622]153    //! Called by BaseObject when visibility has changed.
[1615]154    void OrxonoxOverlay::changedVisibility()
[1595]155    {
[1622]156        if (!this->overlay_)
157            return;
158
159        if (this->isVisible())
160            this->overlay_->show();
161        else
162            this->overlay_->hide();
[1595]163    }
[1588]164
[1622]165    /**
166    @brief
167        Called by the GraphicsEngine whenever the window size changes.
168        Calculates the aspect ratio only.
169    */
[1615]170    void OrxonoxOverlay::windowResized(int newWidth, int newHeight)
171    {
172        this->windowAspectRatio_ = newWidth/(float)newHeight;
[1622]173        this->sizeCorrectionChanged();
[1615]174    }
[1590]175
[1622]176    /**
177    @brief
178        Called whenever the rotation angle has changed.
179    */
180    void OrxonoxOverlay::angleChanged()
[1595]181    {
[1622]182        if (!this->overlay_)
183            return;
184
185        this->overlay_->setRotate(this->angle_);
[1615]186        this->sizeCorrectionChanged();
[1595]187    }
[1615]188
[1622]189    /**
190    @brief
191        Called whenever the aspect ratio or the angle has changed.
192        The method calculates a correction factor for the size to compensate
193        for aspect distortion if desired.
194    @remarks
195        This only works when the angle is about 0 or 90 degrees.
196    */
[1615]197    void OrxonoxOverlay::sizeCorrectionChanged()
[1595]198    {
[1615]199        if (this->bCorrectAspect_)
200        {
201            float angle = this->angle_.valueDegrees();
[1618]202            if (angle < 0.0)
203                angle = -angle;
204            angle -= 180.0 * (int)(angle / 180.0);
205
[1622]206            // take the reverse if angle is about 90 degrees
[1615]207            float tempAspect;
[1618]208            if (angle > 89.0 && angle < 91.0)
[1632]209            {
[1615]210                tempAspect = 1.0 / this->windowAspectRatio_;
[1632]211                rotState_ = Vertical;
212            }
[1618]213            else if (angle > 179 || angle < 1)
[1632]214            {
[1615]215                tempAspect = this->windowAspectRatio_;
[1632]216                rotState_ = Horizontal;
217            }
[1615]218            else
[1632]219            {
[1615]220                tempAspect = 1.0;
[1632]221                rotState_ = Inbetween;
222            }
[1615]223
224            // note: this is only an approximation that is mostly valid when the
225            // magnitude of the width is about the magnitude of the height.
226            // Correctly we would have to take the square root of width*height
227            this->sizeCorrection_.x = 2.0 / (tempAspect + 1.0);
228            this->sizeCorrection_.y = tempAspect * this->sizeCorrection_.x;
229        }
230        else
231        {
232            this->sizeCorrection_ = Vector2::UNIT_SCALE;
233        }
[1622]234
[1615]235        this->sizeChanged();
[1595]236    }
237
[1615]238    /**
[1622]239    @brief
240        Sets the overlay size using the actual corrected size.
[1615]241    */
242    void OrxonoxOverlay::sizeChanged()
243    {
[1622]244        if (!this->overlay_)
245            return;
246
[1615]247        this->overlay_->setScale(size_.x * sizeCorrection_.x, size_.y * sizeCorrection_.y);
248        positionChanged();
249    }
[1595]250
[1615]251    /**
[1622]252    @brief
253        Determines the position of the overlay.
254        This works also well when a rotation angle is applied. The overlay always
255        gets aligned correctly as well as possible.
[1615]256    */
[1622]257    void OrxonoxOverlay::positionChanged()
[1615]258    {
[1622]259        if (!this->overlay_)
260            return;
[1595]261
[1622]262        // transform the angle to a range of 0 - pi/2 first.
[1617]263        float angle = this->angle_.valueRadians();
264        if (angle < 0.0)
265            angle = -angle;
[1615]266        angle -= Ogre::Math::PI * (int)(angle / (Ogre::Math::PI));
267        if (angle > Ogre::Math::PI * 0.5)
268            angle = Ogre::Math::PI - angle;
[1747]269
[1622]270        // do some mathematical fiddling for a bounding box
[1615]271        Vector2 actualSize = size_ * sizeCorrection_;
272        float radius = actualSize.length();
273        float phi = atan(actualSize.y / actualSize.x);
274        Vector2 boundingBox(radius * cos(angle - phi), radius * sin(angle + phi));
[1622]275
276        // calculate the scrolling offset
277        Vector2 scroll = (position_ - 0.5 - boundingBox * (pickPoint_ - 0.5)) * 2.0;
[1615]278        this->overlay_->setScroll(scroll.x, -scroll.y);
279    }
[1598]280
[1615]281
[1622]282    //########### Console commands ############
283
284    /**
285    @brief
286        Scales an overlay by its name.
287    @param name
288        The name of the overlay defined BaseObject::setName() (usually done with the "name"
[1623]289        attribute in the xml file).
[1622]290    */
[1615]291    /*static*/ void OrxonoxOverlay::scaleOverlay(const std::string& name, float scale)
292    {
293        std::map<std::string, OrxonoxOverlay*>::const_iterator it = overlays_s.find(name);
294        if (it != overlays_s.end())
295            (*it).second->scale(Vector2(scale, scale));
296    }
297
[1622]298    /**
299    @brief
300        Scrolls an overlay by its name.
301    @param name
302        The name of the overlay defined BaseObject::setName() (usually done with the "name"
[1623]303        attribute in the xml file).
[1622]304    */
[1615]305    /*static*/ void OrxonoxOverlay::scrollOverlay(const std::string& name, const Vector2& scroll)
306    {
307        std::map<std::string, OrxonoxOverlay*>::const_iterator it = overlays_s.find(name);
308        if (it != overlays_s.end())
309            (*it).second->scroll(scroll);
310    }
311
[1622]312    /**
313    @brief
314        Rotates an overlay by its name.
315    @param name
316        The name of the overlay defined BaseObject::setName() (usually done with the "name"
[1623]317        attribute in the xml file).
[1622]318    */
[1615]319    /*static*/ void OrxonoxOverlay::rotateOverlay(const std::string& name, const Degree& angle)
320    {
321        std::map<std::string, OrxonoxOverlay*>::const_iterator it = overlays_s.find(name);
322        if (it != overlays_s.end())
323            (*it).second->rotate(angle);
324    }
[1588]325}
Note: See TracBrowser for help on using the repository browser.