Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jun 21, 2008, 2:35:24 PM (16 years ago)
Author:
rgrieder
Message:
  • Dots on the Radar actually disappear now when a Ship gets destroyed…
  • svn save to keep History of HUDText when renaming AND moving
Location:
code/branches/hud/src/orxonox/overlays/hud
Files:
2 deleted
10 edited

Legend:

Unmodified
Added
Removed

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

    r1609 r1614  
    3535#include <OgreMaterialManager.h>
    3636#include <OgreTechnique.h>
     37#include <OgrePanelOverlayElement.h>
    3738
    3839#include "util/Convert.h"
    … …  
    4546
    4647    HUDBar::HUDBar()
     48        : bar_(0)
     49        , textureUnitState_(0)
    4750    {
    4851        RegisterObject(HUDBar);
    49 
    50         this->bar_ = 0;
    51         this->background_ = 0;
    52         this->textureUnitState_ = 0;
    53 
    54         barWidth_s = 0.88f;
    55         barHeight_s = 1.0f;
    56         barOffsetLeft_s = 0.06f;
    57         barOffsetTop_s = 0.0f;
    58 
    59         this->value_ = -1;
    60         this->autoColour_ = true;
    61         this->right2Left_ = false; // default is left to right progress
    6252    }
    6353
    … …  
    6858            if (this->bar_)
    6959                OverlayManager::getSingleton().destroyOverlayElement(this->bar_);
     60            // FIXME: Check whether we have to delete the textureUnitState_;
    7061        }
    7162    }
    … …  
    7768        if (mode == XMLPort::LoadObject)
    7869        {
    79             // create background
    80             this->background_ = static_cast<PanelOverlayElement*>(
    81                     OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_Background_" + getUniqueNumberStr()));
    82             this->background_->setMaterialName("Orxonox/BarBackground");
    83             this->overlay_->add2D(this->background_);
    84 
    8570            // create new material
    8671            std::string materialname = "barmaterial" + getConvertedValue<unsigned int, std::string>(materialcount_s++);
    … …  
    9378
    9479            // create bar
     80            barWidth_s = 0.88f;
     81            barHeight_s = 1.0f;
     82            barOffsetLeft_s = 0.06f;
     83            barOffsetTop_s = 0.0f;
    9584            this->bar_ = static_cast<PanelOverlayElement*>(OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "Bar" + getUniqueNumberStr()));
    9685            this->bar_->setMaterialName(materialname);
    9786            this->background_->addChild(bar_);
    98         }
    9987
    100         XMLPortParamLoadOnly(HUDBar, "value", setValue, xmlElement, mode);
     88            this->setValue(0);
     89            this->autoColour_ = true;
     90            this->right2Left_ = false; // default is left to right progress
    10191
    102         if (mode == XMLPort::LoadObject)
    103         {
    10492            this->addColour(0.7, ColourValue(0.2, 0.7, 0.2));
    10593            this->addColour(0.4, ColourValue(0.7, 0.5, 0.2));
    10694            this->addColour(0.1, ColourValue(0.7, 0.2, 0.2));
    10795        }
     96
     97        XMLPortParamLoadOnly(HUDBar, "value", setValue, xmlElement, mode);
    10898    }
    10999

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

    r1601 r1614  
    3434#include "OrxonoxPrereqs.h"
    3535
     36#include <map>
    3637#include <OgrePrerequisites.h>
    37 #include <OgrePanelOverlayElement.h>
    38 
    3938#include "util/Math.h"
    4039#include "overlays/OrxonoxOverlay.h"
    … …  
    6766      float value_;                       // progress of bar
    6867      Ogre::PanelOverlayElement* bar_;
    69       Ogre::PanelOverlayElement* background_;
    7068      Ogre::TextureUnitState* textureUnitState_;
    7169      std::map<float, ColourValue> colours_;

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

    r1599 r1614  
    2929#include "OrxonoxStableHeaders.h"
    3030#include "HUDFPSText.h"
     31#include <OgreTextAreaOverlayElement.h>
    3132#include "GraphicsEngine.h"
    3233#include "util/Convert.h"

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

    r1613 r1614  
    3131
    3232#include <OgreOverlayManager.h>
    33 #include <OgreStringConverter.h>
    34 
    35 //#include "GraphicsEngine.h"
    36 // TODO: remove the SpaceShip and CameraHandler dependencies
    37 #include "core/Debug.h"
    38 #include "core/CoreIncludes.h"
     33#include <OgreTextAreaOverlayElement.h>
     34#include <OgrePanelOverlayElement.h>
     35
     36#include "util/Math.h"
    3937#include "core/ConsoleCommand.h"
    4038#include "objects/SpaceShip.h"
    4139#include "objects/Projectile.h"
    4240#include "objects/CameraHandler.h"
    43 #include "overlays/OverlayGroup.h"
    4441#include "Radar.h"
    4542
    … …  
    6865        if (this->isInitialized())
    6966        {
    70             if (this->container_)
    71                 OverlayManager::getSingleton().destroyOverlayElement(this->container_);
    7267            if (this->navMarker_)
    7368                OverlayManager::getSingleton().destroyOverlayElement(this->navMarker_);
    … …  
    7671            if (this->aimMarker_)
    7772                OverlayManager::getSingleton().destroyOverlayElement(this->aimMarker_);
     73            if (this->container_)
     74                OverlayManager::getSingleton().destroyOverlayElement(this->container_);
    7875        }
    7976
    … …  
    8784        if (mode == XMLPort::LoadObject)
    8885        {
    89             // create container
     86            // create container because we cannot add a Text element to an Overlay
    9087            container_ = static_cast<OverlayContainer*>(Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_navContainer"));
    9188

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

    r1613 r1614  
    3333
    3434#include <OgrePrerequisites.h>
    35 #include <OgreTextAreaOverlayElement.h>
    36 #include <OgrePanelOverlayElement.h>
    3735#include "overlays/OrxonoxOverlay.h"
    38 #include "util/Math.h"
    3936
    4037namespace orxonox
    … …  
    5047        void tick(float dt);
    5148
    52         //void cycleFocus();
    5349        float getDist2Focus() const;
    54 
    55         /*inline RadarObject* getFocus() const
    56             { return this->focus_; }
    57         void releaseFocus();*/
    58 
    59         /*static void cycleNavigationFocus();
    60         static void releaseNavigationFocus();
    61         static HUDNavigation& getInstance();*/
    6250
    6351      protected:
    … …  
    8876        Ogre::TextAreaOverlayElement* navText_;     //!< Text overlay to display the target distance
    8977        bool wasOutOfView_;                         //!< Performance booster variable: setMaterial is not cheap
    90 
    91         //static HUDNavigation* instance_s;
    9278  };
    9379}

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

    r1599 r1614  
    2929#include "OrxonoxStableHeaders.h"
    3030#include "HUDRTRText.h"
     31#include <OgreTextAreaOverlayElement.h>
    3132#include "GraphicsEngine.h"
    3233#include "util/Convert.h"

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

    r1613 r1614  
    2222 *   Author:
    2323 *      Yuning Chai
     24 *      Felix Schulthess
    2425 *   Co-authors:
    25  *      Felix Schulthess
     26 *      Reto Grieder
    2627 *
    2728 */
    … …  
    3031#include "HUDRadar.h"
    3132
    32 #include <assert.h>
    3333#include <OgreOverlayManager.h>
    34 #include <OgreMaterialManager.h>
     34#include <OgrePanelOverlayElement.h>
    3535
     36#include "util/Math.h"
    3637#include "core/ConsoleCommand.h"
    3738#include "objects/SpaceShip.h"
    3839#include "objects/WorldEntity.h"
    3940#include "tools/TextureGenerator.h"
    40 #include "RadarViewable.h"
     41#include "Radar.h"
    4142
    4243namespace orxonox
    4344{
    4445    CreateFactory(HUDRadar);
    45     CreateFactory(RadarShape);
    4646
    4747    using namespace Ogre;
    4848
    4949    HUDRadar::HUDRadar()
    50       : background_(0)
    51       , marker_(0)
    52       , sensitivity_(1.0f)
     50        : marker_(0)
    5351    {
    5452        RegisterObject(HUDRadar);
    … …  
    5957        if (this->isInitialized())
    6058        {
    61             /*if (this->background_)
    62                 OverlayManager::getSingleton().destroyOverlayElement(this->background_);
    63             while (this->radarDots_.size() > 0)
     59            if (this->marker_)
     60                OverlayManager::getSingleton().destroyOverlayElement(this->marker_);
     61            for (std::vector<Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.begin();
     62                it != this->radarDots_.end(); ++it)
    6463            {
    65                 OverlayManager::getSingleton().destroyOverlayElement(this->radarDots_[this->radarDots_.size() - 1]);
    66                 this->radarDots_.pop_back();
    67             }*/
     64                OverlayManager::getSingleton().destroyOverlayElement(*it);
     65            }
    6866        }
    6967    }
    … …  
    9088        if (mode == XMLPort::LoadObject)
    9189        {
    92             background_ = (Ogre::PanelOverlayElement*)Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_Background");
    93             background_->setMaterialName("Orxonox/Radar");
    94             overlay_->add2D(background_);
    95 
    9690            marker_ = (Ogre::PanelOverlayElement*)Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_Marker");
    9791            marker_->setMaterialName("Orxonox/RadarMarker");
    … …  
    10094        }
    10195    }
    102 
    103     /*void HUDRadar::addShape(RadarShape* shape)
    104     {
    105         this->shapes_[shape->getIndex()] = shape;
    106     }
    107 
    108     RadarShape* HUDRadar::getShape(unsigned int index) const
    109     {
    110         if (index < this->shapes_.size())
    111         {
    112             std::map<unsigned int, RadarShape*>::const_iterator it = shapes_.begin();
    113             for (unsigned int i = 0; i != index; ++it, ++i)
    114                 ;
    115             return (*it).second;
    116         }
    117         else
    118             return 0;
    119     }*/
    12096
    12197    void HUDRadar::displayObject(RadarViewable* object, bool bIsMarked)
    … …  
    131107        }
    132108
    133         /*static int counter = 0;
    134         if (++counter < 1120 && counter > 120)
    135         {
    136             // we have to create a new entry
    137             Ogre::PanelOverlayElement* panel = static_cast<Ogre::PanelOverlayElement*>(
    138                 Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberStr()));
    139             // get right material
    140             panel->setMaterialName("Orxonox/RadarSquare");
    141             panel->setDimensions(0.03, 0.03);
    142             panel->setPosition((1.0 + (rand() & 0xFF) / 256.0 - 0.001) * 0.5, (1.0 - (rand() & 0xFF) / 256.0 - 0.001) * 0.5);
    143             panel->show();
    144             this->overlay_->add2D(panel);
    145             this->overlay_->show();
    146         }*/
    147 
    148109        // try to find a panel already created
    149110        Ogre::PanelOverlayElement* panel;
    150         std::map<RadarViewable*, Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.find(object);
    151         if (it == this->radarDots_.end())
     111        //std::map<RadarViewable*, Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.find(object);
     112        if (itRadarDots_ == this->radarDots_.end())
    152113        {
    153114            // we have to create a new entry
    154115            panel = static_cast<Ogre::PanelOverlayElement*>(
    155116                Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberStr()));
    156             radarDots_[object] = panel;
     117            radarDots_.push_back(panel);
    157118            // get right material
    158119            panel->setMaterialName(TextureGenerator::getMaterialName(
    159120                shapeMaterials_[object->getRadarObjectType()], object->getRadarObjectColour()));
    160121            this->overlay_->add2D(panel);
     122            this->itRadarDots_ = this->radarDots_.end();
    161123        }
    162124        else
    163             panel = (*it).second;
     125        {
     126            panel = *itRadarDots_;
     127            ++itRadarDots_;
     128            std::string materialName = TextureGenerator::getMaterialName(
     129                shapeMaterials_[object->getRadarObjectType()], object->getRadarObjectColour());
     130            if (materialName != panel->getMaterialName())
     131                panel->setMaterialName(materialName);
     132        }
    164133
    165134        // set size to fit distance...
    … …  
    177146        {
    178147            this->marker_->show();
    179             this->marker_->setDimensions(size * 1.2, size * 1.2);
    180             this->marker_->setPosition((1.0 + coord.x - size * 1.2) * 0.5, (1.0 - coord.y - size * 1.2) * 0.5);
     148            this->marker_->setDimensions(size * 1.5, size * 1.5);
     149            this->marker_->setPosition((1.0 + coord.x - size * 1.5) * 0.5, (1.0 - coord.y - size * 1.5) * 0.5);
    181150        }
    182151    }
    … …  
    184153    void HUDRadar::radarTick(float dt)
    185154    {
     155        this->itRadarDots_ = this->radarDots_.begin();
     156        this->marker_->hide();
    186157    }
    187 
    188     /*void HUDRadar::tick(float dt)
    189     {
    190         // iterate through all RadarObjects
    191         unsigned int i = 0;
    192         for (Iterator<RadarViewable> it = ObjectList<RadarViewable>::start(); it; ++it, ++i)
    193         {
    194             if ((*it)->isVisibleOnRadar())
    195             {
    196             }
    197         }
    198     }*/
    199 
    200     /*void HUDRadar::listObjects()
    201     {
    202         COUT(3) << "List of RadarObjects:\n";
    203         // iterate through all Radar Objects
    204         unsigned int i = 0;
    205         for (Iterator<RadarViewable> it = ObjectList<RadarViewable>::start(); it; ++it, ++i)
    206         {
    207             COUT(3) << i++ << ": " << (*it)->getWorldEntity()->getWorldPosition() << std::endl;
    208         }
    209     }*/
    210158}

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

    r1613 r1614  
    2222 *   Author:
    2323 *      Yuning Chai
     24 *      Felix Schulthess
    2425 *   Co-authors:
    25  *      Felix Schulthess
     26 *      Reto Grieder
    2627 *
    2728 */
    … …  
    3233#include "OrxonoxPrereqs.h"
    3334
     35#include <vector>
     36#include <map>
    3437#include <OgrePrerequisites.h>
    35 #include <OgrePanelOverlayElement.h>
    3638#include "overlays/OrxonoxOverlay.h"
    37 #include "objects/Tickable.h"
    38 #include "core/BaseObject.h"
    39 #include "util/Math.h"
    40 #include "core/Debug.h"
    41 #include "Radar.h"
     39#include "RadarListener.h"
     40#include "RadarViewable.h"
    4241
    4342namespace orxonox
    4443{
    45     template <class T, int Dummy>
    46     class _OrxonoxExport RadarAttribute : public BaseObject
    47     {
    48       public:
    49         RadarAttribute();
    50         ~RadarAttribute() { }
    51 
    52         void XMLPort(Element& xmlElement, XMLPort::Mode mode);
    53         void loadAttribute(Element& xmlElement, XMLPort::Mode mode);
    54 
    55         void setAttribute(const T& attribute) { this->attribute_ = attribute; }
    56         const T& getAttribute() const { return this->attribute_; }
    57 
    58         void setIndex(unsigned int index);
    59         unsigned int getIndex() { return this->index_; }
    60 
    61       private:
    62         unsigned int index_;
    63         T attribute_;
    64     };
    65 
    66     template <class T, int Dummy>
    67     void RadarAttribute<T, Dummy>::setIndex(unsigned int index)
    68     {
    69         if (index > 0xFF)
    70         {
    71             COUT(1) << "Shape index was larger than 255 while parsing a RadarAttribute. "
    72               << "Using random number!!!" << std::endl;
    73             this->index_ = rand() & 0xFF;
    74         }
    75         else
    76             this->index_ = index;
    77     }
    78 
    79     typedef RadarAttribute<std::string, 1> RadarShape;
    80 
    81     template <>
    82     RadarShape::RadarAttribute() : index_(0)
    83         { RegisterObject(RadarShape); }
    84 
    85     template <>
    86     void RadarShape::XMLPort(Element& xmlElement, XMLPort::Mode mode)
    87     {
    88         BaseObject::XMLPort(xmlElement, mode);
    89         XMLPortParam(RadarShape, "shape", setAttribute, getAttribute, xmlElement, mode);
    90         XMLPortParam(RadarShape, "index", setIndex, getIndex, xmlElement, mode);
    91     }
    92 
    93 
    94     class _OrxonoxExport HUDRadar : public OrxonoxOverlay, public RadarListener//, public Tickable
     44    class _OrxonoxExport HUDRadar : public OrxonoxOverlay, public RadarListener
    9545    {
    9646      public:
    … …  
    9949
    10050        void XMLPort(Element& xmlElement, XMLPort::Mode mode);
    101 
    102         /*void addShape(RadarShape* shape);
    103         RadarShape* getShape(unsigned int index) const;*/
    10451
    10552        float getRadarSensitivity() const { return this->sensitivity_; }
    … …  
    11259        void setMaximumDotSize(float size) { this->maximumDotSize_ = size; }
    11360
    114         //void tick(float dt);
    115 
    116         //void listObjects();
    117 
    11861      private:
    11962        void displayObject(RadarViewable* viewable, bool bIsMarked);
    120         void hideMarker() { this->marker_->hide(); }
    12163        float getRadarSensitivity() { return 1.0f; }
    12264        void radarTick(float dt);
    … …  
    12466        std::map<RadarViewable::Shape, std::string> shapeMaterials_;
    12567
    126         Ogre::PanelOverlayElement* background_;
    127         std::map<RadarViewable*, Ogre::PanelOverlayElement*> radarDots_;
     68        std::vector<Ogre::PanelOverlayElement*> radarDots_;
     69        std::vector<Ogre::PanelOverlayElement*>::iterator itRadarDots_;
    12870        Ogre::PanelOverlayElement* marker_;
    12971

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

    r1599 r1614  
    2121 *
    2222 *   Author:
     23 *      Felix Schulthess
    2324 *      Reto Grieder
    2425 *   Co-authors:

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

    r1599 r1614  
    2121 *
    2222 *   Author:
     23 *      Felix Schulthess
    2324 *      Reto Grieder
    2425 *   Co-authors:
Note: See TracChangeset for help on using the changeset viewer.