Changeset 1613 for code/branches/hud

Timestamp:

Jun 20, 2008, 12:05:12 AM (16 years ago)

Author:

rgrieder

Message:

• Radar now working like before
• but more of a svn save..

There is class called Radar which takes care of the focus and all objects that can be displayed on a Radar.
The actual visual implementation is in HUDRadar.
To make a object radar viewable, simply implement RadarViewable and set the WorldEntitiy pointer in the constructor (assertation will fail otherwise!).
You can also set a camouflage value between 0 and 1 that tells how good a radar can see an object.
The HUDRadar (or another one) on the other side has a sensitivity between 0 and 1. So only if the sensitivity is higher than the camouflage value, the object gets displayed.

Location:

code/branches/hud

Files:

• src/core/Iterator.h (modified) (1 diff)
• src/orxonox/CMakeLists.txt (modified) (2 diffs)
• src/orxonox/Orxonox.cc (modified) (4 diffs)
• src/orxonox/Orxonox.h (modified) (1 diff)
• src/orxonox/Radar.cc (modified) (4 diffs)
• src/orxonox/Radar.h (modified) (3 diffs)
• src/orxonox/RadarViewable.cc (moved) (moved from code/branches/hud/src/orxonox/overlays/hud/RadarViewable.cc) (2 diffs)
• src/orxonox/RadarViewable.h (moved) (moved from code/branches/hud/src/orxonox/overlays/hud/RadarViewable.h) (1 diff)
• src/orxonox/objects/SpaceShip.cc (modified) (5 diffs)
• src/orxonox/objects/SpaceShip.h (modified) (1 diff)
• src/orxonox/overlays/hud/HUDNavigation.cc (modified) (10 diffs)
• src/orxonox/overlays/hud/HUDNavigation.h (modified) (2 diffs)
• src/orxonox/overlays/hud/HUDRadar.cc (modified) (10 diffs)
• src/orxonox/overlays/hud/HUDRadar.h (modified) (2 diffs)
• src/orxonox/tools/TextureGenerator.cc (modified) (1 diff)
• visual_studio/orxonox_vc8.suo (deleted)
• visual_studio/vc8/orxonox.vcproj (modified) (4 diffs)

code/branches/hud/src/core/Iterator.h

@@ -92 +92 @@
             {
                 this->element_ = element;
+                return *this;
             }
 

code/branches/hud/src/orxonox/CMakeLists.txt

@@ -4 +4 @@
   Orxonox.cc
   Radar.cc
+  RadarViewable.cc
   Settings.cc
 
@@ -18 +19 @@
   overlays/hud/HUDSpeedBar.cc
   overlays/hud/HUDText.cc
-  overlays/hud/RadarObject.cc
-  overlays/hud/RadarViewable.cc
+  overlays/hud/HUDRadar.cc
 
   tolua/tolua_bind.cc

code/branches/hud/src/orxonox/Orxonox.cc

@@ -76 +76 @@
 #include "GraphicsEngine.h"
 #include "Settings.h"
+#include "Radar.h"
 
 // globals for the server or client
@@ -99 +100 @@
     , startLevel_(0)
     , hud_(0)
+    , radar_(0)
     //, auMan_(0)
     , timer_(0)
@@ -126 +128 @@
       delete this->hud_;
 
+    if (this->radar_)
+      delete this->radar_;
+
     Loader::close();
     //if (this->auMan_)
@@ -342 +347 @@
     // Load the HUD
     COUT(3) << "Orxonox: Loading HUD" << std::endl;
-
     hud_ = new Level(Settings::getDataPath() + "overlay/hud.oxo");
     Loader::load(hud_);
+
+    // Start the Radar
+    this->radar_ = new Radar();
 
     return true;

code/branches/hud/src/orxonox/Orxonox.h

@@ -95 +95 @@
       Level*                startLevel_;    //!< current hard coded default level
       Level*                hud_;           //!< 'level' object fo the HUD
+      Radar*                radar_;         //!< represents the Radar (not the HUD part)
       //audio::AudioManager*  auMan_;         //!< audio manager
       Ogre::Timer*          timer_;         //!< Main loop timer

code/branches/hud/src/orxonox/Radar.cc

@@ -34 +34 @@
 #include "OrxonoxStableHeaders.h"
 #include "Radar.h"
+#include <float.h>
 #include "objects/WorldEntity.h"
-#include "overlays/hud/RadarViewable.h"
-
+#include "objects/SpaceShip.h"
 #include "core/CoreIncludes.h"
 //#include "core/ConfigValueIncludes.h"
@@ -47 +47 @@
     }
 
+    SetConsoleCommand(Radar, cycleNavigationFocus, true).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(Radar, releaseNavigationFocus, true).setAccessLevel(AccessLevel::User);
 
     Radar* Radar::instance_s = 0;
 
     Radar::Radar()
+        : focus_(0)
+        , objectTypeCounter_(0)
     {
         assert(instance_s == 0);
         instance_s = this;
+
+        // TODO: make this mapping configurable. Maybe there's a possibility with self configured
+        //       configValues..
+        this->objectTypes_["Asteroid"] = RadarViewable::Dot;
+        this->objectTypes_["SpaceShip"] = RadarViewable::Square;
+        this->objectTypes_["AsdfQwerty"] = RadarViewable::Triangle;
+
+        /*WorldEntity* object;
+        object = new WorldEntity();
+        object->setPosition(2000.0, 0.0, 0.0);
+        addRadarObject(object, ColourValue(0.5, 0, 0, 1));
+        object = new WorldEntity();
+        object->setPosition(0.0, 2000.0, 0.0);
+        addRadarObject(object, ColourValue(0.5, 0, 0, 1));
+        object = new WorldEntity();
+        object->setPosition(0.0, 0.0, 2000.0);
+        addRadarObject(object, ColourValue(0.5, 0, 0, 1));
+        object = new WorldEntity();
+        object->setPosition(10000.0,16000.0,0.0);
+        addRadarObject(object);*/
+
     }
 
@@ -61 +86 @@
     }
 
-    Radar& Radar::getInstance()
+    /*void Radar::unregisterObject(RadarViewable* object)
+    {
+        if (this->focus_ == object)
+            this->focus_ = 0;
+        // TODO: check for focus
+    }*/
+
+    const RadarViewable* Radar::getFocus()
+    {
+        return *(this->itFocus_);
+    }
+
+    RadarViewable::Shape Radar::addObjectDescription(const std::string name)
+    {
+        std::map<std::string, RadarViewable::Shape>::iterator it = this->objectTypes_.find(name);
+        if (it == this->objectTypes_.end())
+            return this->objectTypes_[name] = RadarViewable::Square; // default, configure!!
+        else
+            return this->objectTypes_[name];
+    }
+
+
+    void Radar::tick(float dt)
+    {
+        if (this->focus_ != *(this->itFocus_))
+        {
+            // focus object was deleted, release focus
+            this->focus_ = 0;
+            this->itFocus_ = 0;
+        }
+
+        for (Iterator<RadarListener> itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
+            for (Iterator<RadarViewable> itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
+            {
+                if ((*itElement) != SpaceShip::getLocalShip() && (*itListener)->getRadarSensitivity() > (*itElement)->getRadarObjectCamouflage())
+                    (*itListener)->displayObject(*itElement, *itElement == this->focus_);
+            }
+
+            (*itListener)->radarTick(dt);
+
+            if (this->focus_ == 0)
+                (*itListener)->hideMarker();
+        }
+    }
+
+    void Radar::cycleFocus()
+    {
+        if (*(ObjectList<RadarViewable>::begin()) == 0)
+        {
+            // list is empty
+            this->itFocus_ = 0;
+            this->focus_ = 0;
+        }
+        else
+        {
+            Vector3 localPosition = SpaceShip::getLocalShip()->getPosition();
+            Vector3 targetPosition = localPosition;
+            if (*(this->itFocus_))
+                targetPosition = this->itFocus_->getWorldPosition();
+
+            // find the closed object further away than targetPosition
+            float currentDistance = localPosition.squaredDistance(targetPosition);
+            float nextDistance = FLT_MAX;
+            float minimumDistance = FLT_MAX;
+            Iterator<RadarViewable> itFallback = 0;
+
+            for (Iterator<RadarViewable> it = ObjectList<RadarViewable>::begin(); it; ++it)
+            {
+                if (*it == SpaceShip::getLocalShip())
+                    continue;
+
+                float targetDistance = localPosition.squaredDistance((*it)->getWorldPosition());
+                if (targetDistance > currentDistance && targetDistance < nextDistance)
+                {
+                    this->itFocus_ = it;
+                    nextDistance = targetDistance;
+                }
+                if (targetDistance < minimumDistance)
+                {
+                    itFallback = it;
+                    minimumDistance = targetDistance;
+                }
+            }
+
+            if (nextDistance == FLT_MAX)
+            {
+                // we already had the furthest object
+                this->itFocus_ = itFallback;
+                this->focus_ = *itFallback;
+            }
+            else
+            {
+                this->focus_ = *(this->itFocus_);
+            }
+        }
+    }
+
+    void Radar::releaseFocus()
+    {
+        this->itFocus_ = 0;
+        this->focus_ = 0;
+    }
+
+
+    /*static*/ Radar& Radar::getInstance()
     {
         assert(instance_s);
@@ -67 +197 @@
     }
 
-    void Radar::unregisterObject(RadarViewable* object)
-    {
-        // TODO: check for focus
-    }
-
-    void Radar::tick(float dt)
-    {
-        for (Iterator<RadarListener> itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
-        {
-            for (Iterator<RadarViewable> itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
-            {
-                if ((*itListener)->getRadarSensitivity() > (*itElement)->getRadarObjectVisibility())
-                    (*itListener)->displayObject(*itElement);
-            }
-        }
+    /*static*/ void Radar::cycleNavigationFocus()
+    {
+        // avoid using getInstance because of the assert().
+        // User might call this fuction even if HUDNavigation doesn't exist.
+        if (instance_s)
+            instance_s->cycleFocus();
+    }
+
+    /*static*/ void Radar::releaseNavigationFocus()
+    {
+        // avoid using getInstance because of the assert().
+        // User might call this fuction even if HUDNavigation doesn't exist.
+        if (instance_s)
+            instance_s->releaseFocus();
     }
 }

code/branches/hud/src/orxonox/Radar.h

@@ -38 +38 @@
 
 #include <string>
+#include "core/Iterator.h"
 #include "core/OrxonoxClass.h"
 #include "objects/Tickable.h"
+#include "RadarViewable.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport RadarListener : public OrxonoxClass
+    class _OrxonoxExport RadarListener : virtual public OrxonoxClass
     {
     public:
@@ -49 +51 @@
         virtual ~RadarListener() { }
 
-        virtual void displayObject(RadarViewable* viewable) = 0;
+        virtual void displayObject(RadarViewable* viewable, bool bIsMarked) = 0;
+        virtual void hideMarker() = 0;
         virtual float getRadarSensitivity() = 0;
+        virtual void radarTick(float dt) = 0;
     };
 
@@ -69 +73 @@
         ~Radar();
 
-        void unregisterObject(RadarViewable* object);
-
-        void tick(float dt);
+        //void unregisterObject(RadarViewable* object);
+        const RadarViewable* getFocus();
+        RadarViewable::Shape addObjectDescription(const std::string name);
 
         static Radar& getInstance();
         static Radar* getInstancePtr() { return instance_s; }
 
+        static void cycleNavigationFocus();
+        static void releaseNavigationFocus();
+
     private:
         Radar(Radar& instance);
+        void tick(float dt);
+
+        void releaseFocus();
+        void updateFocus();
+        void cycleFocus();
+
+        Iterator<RadarViewable> itFocus_;
+        RadarViewable* focus_;
+        std::map<std::string, RadarViewable::Shape> objectTypes_;
+        int objectTypeCounter_; 
 
         static Radar* instance_s;

code/branches/hud/src/orxonox/RadarViewable.cc

@@ -38 +38 @@
     */
     RadarViewable::RadarViewable()
-        : radarObjectVisibility_(1.0f)
+        : radarObjectCamouflage_(0.0f)
+        , radarObjectType_(Dot)
         , radarObject_(0)
+        , radarObjectDescription_("staticObject")
     {
         RegisterRootObject(RadarViewable);
     }
 
-    void RadarViewable::unregisterFromRadar()
+    void RadarViewable::setRadarObjectDescription(const std::string& str)
+    {
+        Radar* radar = Radar::getInstancePtr();
+        if (radar)
+            this->radarObjectType_ = radar->addObjectDescription(str);
+        else
+        {
+            CCOUT(2) << "Attempting to access the radar, but the radar is non existent." << std::endl;
+        }
+        this->radarObjectDescription_ = str;
+    }
+
+    /*void RadarViewable::unregisterFromRadar()
     {
         Radar* radar = Radar::getInstancePtr();
@@ -53 +67 @@
             CCOUT(2) << "Attempting to unregister an object to the radar, but the radar is non existent." << std::endl;
         }
-    }
+    }*/
 }

code/branches/hud/src/orxonox/RadarViewable.h

@@ -43 +43 @@
     {
     public:
+        enum Shape
+        {
+            Square,
+            Dot,
+            Triangle
+        };
+
+    public:
         RadarViewable();
-        virtual ~RadarViewable() { unregisterFromRadar(); }
+        virtual ~RadarViewable() { }//unregisterFromRadar(); }
 
-        void unregisterFromRadar();
-
-        float getRadarObjectVisibility() const { return this->radarObjectVisibility_; }
-        void setRadarObjectVisibility(float visibility) { this->radarObjectVisibility_ = visibility; }
-
-        const std::string& getRadarObjectType() const { return this->radarObjectType_; }
-        void setRadarObjectType(const std::string& type) { this->radarObjectType_ = type; }
+        float getRadarObjectCamouflage() const { return this->radarObjectCamouflage_; }
+        void setRadarObjectCamouflage(float camouflage) { this->radarObjectCamouflage_ = camouflage; }
 
         const ColourValue& getRadarObjectColour() const { return this->radarObjectColour_; }
         void setRadarObjectColour(const ColourValue& colour) { this->radarObjectColour_ = colour; }
 
+        const std::string& getRadarObjectDescription() const { return this->radarObjectDescription_; }
+        void setRadarObjectDescription(const std::string& str);
+
+        const WorldEntity* getWorldEntity() const { return this->radarObject_; }
+        const Vector3& getWorldPosition() const { validate(); return this->radarObject_->getWorldPosition(); }
+        Vector3 getOrientedVelocity() const
+            { validate(); return this->radarObject_->getOrientation() * this->radarObject_->getVelocity(); }
+
+        Shape getRadarObjectType() const { return this->radarObjectType_; }
+
+    protected:
+        WorldEntity* radarObject_;
+        //void unregisterFromRadar();
+
     private:
-        float radarObjectVisibility_;
-        WorldEntity* radarObject_;
-        std::string radarObjectType_;
+        void validate() const { if (!this->radarObject_)
+        { COUT(1) << "Assertation: Every RadarViewable has to be assigned a WorldEntity pointer!" << std::endl; assert(0); } }
+
+        float radarObjectCamouflage_;
+        Shape radarObjectType_;
+        std::string radarObjectDescription_;
         ColourValue radarObjectColour_;
     };

code/branches/hud/src/orxonox/objects/SpaceShip.cc

@@ -42 +42 @@
 #include "core/Debug.h"
 #include "GraphicsEngine.h"
-#include "core/input/InputManager.h"
+//#include "core/input/InputManager.h"
 #include "tools/ParticleInterface.h"
 #include "RotatingProjectile.h"
@@ -49 +49 @@
 #include "core/ConsoleCommand.h"
 #include "network/Client.h"
-#include "overlays/hud/HUDRadar.h"
 
 namespace orxonox
@@ -133 +132 @@
         this->health_ = 100;
 
+        this->radarObject_ = static_cast<WorldEntity*>(this);
+
         COUT(3) << "Info: SpaceShip was loaded" << std::endl;
     }
@@ -144 +145 @@
             if (this->tt2_)
                 delete this->tt2_;
-
-            if (setMouseEventCallback_)
-                InputManager::removeMouseHandler("SpaceShip");
-
             if (this->cam_)
                 delete this->cam_;
-
-            if (!this->myShip_)
-                HUDRadar::getInstance().removeRadarObject(this);
         }
     }
@@ -161 +155 @@
           myShip_=true;
         else
-          HUDRadar::getInstance().addRadarObject(this, this->getProjectileColour());
+          this->setRadarObjectColour(this->getProjectileColour());
       }
       if(Model::create())

code/branches/hud/src/orxonox/objects/SpaceShip.h

@@ -36 +36 @@
 #include "Camera.h"
 #include "Model.h"
+#include "RadarViewable.h"
 #include "tools/BillboardSet.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport SpaceShip : public Model
+    class _OrxonoxExport SpaceShip : public Model, public RadarViewable
     {
         public:

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

@@ -42 +42 @@
 #include "objects/CameraHandler.h"
 #include "overlays/OverlayGroup.h"
-#include "RadarObject.h"
-#include "HUDRadar.h"
+#include "Radar.h"
 
 namespace orxonox
@@ -49 +48 @@
     CreateFactory(HUDNavigation);
 
-    SetConsoleCommand(HUDNavigation, cycleNavigationFocus, true).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(HUDNavigation, releaseNavigationFocus, true).setAccessLevel(AccessLevel::User);
-
-    HUDNavigation* HUDNavigation::instance_s = 0;
+    //HUDNavigation* HUDNavigation::instance_s = 0;
 
     using namespace Ogre;
@@ -61 +57 @@
       , aimMarker_(0)
       , navText_(0)
-      , focus_(0)
     {
         RegisterObject(HUDNavigation);
         
-        assert(instance_s == 0); // singleton class
-        HUDNavigation::instance_s = this;
+        /*assert(instance_s == 0); // singleton class
+        HUDNavigation::instance_s = this;*/
     }
 
@@ -83 +78 @@
         }
 
-        HUDNavigation::instance_s = 0;
+        //HUDNavigation::instance_s = 0;
     }
 
@@ -117 +112 @@
 
             overlay_->add2D(container_);
-            overlay_->hide();
         }
 
@@ -181 +175 @@
     void HUDNavigation::tick(float dt)
     {
-        if (!focus_)
+        if (!Radar::getInstance().getFocus())
+        {
+            this->overlay_->hide();
             return;
+        }
+        else
+        {
+            this->overlay_->show();
+        }
 
         // set text
-        int dist = (int) getDist2Focus()/100.0f;
+        int dist = (int) getDist2Focus();
         navText_->setCaption(convertToString(dist));
         float textLength = convertToString(dist).size() * navText_->getCharHeight() * 0.3;
@@ -192 +193 @@
         Matrix4 transformationMatrix = navCam->getProjectionMatrix() * navCam->getViewMatrix();
         // transform to screen coordinates
-        Vector3 pos = transformationMatrix * focus_->getPosition();
+        Vector3 pos = transformationMatrix * Radar::getInstance().getFocus()->getWorldPosition();
 
         bool outOfView;
@@ -266 +267 @@
 
             Vector3 aimpos = transformationMatrix * getPredictedPosition(SpaceShip::getLocalShip()->getPosition(),
-                    Projectile::getSpeed(), focus_->getPosition(), focus_->getOrientedVelocity());
+                    Projectile::getSpeed(), Radar::getInstance().getFocus()->getWorldPosition(), Radar::getInstance().getFocus()->getOrientedVelocity());
 
             if (wasOutOfView_)
@@ -288 +289 @@
     }
 
-    void HUDNavigation::cycleFocus()
-    {
-        if (!focus_)
-        {
-            // Get closest object
-            float distance = (unsigned int) -1;
-            Vector3 shipPos = SpaceShip::getLocalShip()->getPosition();
-            it_ = HUDRadar::getInstance().getRadarObjects().begin();
-
-            for (std::list<RadarObject*>::iterator it = HUDRadar::getInstance().getRadarObjects().begin(); it != HUDRadar::getInstance().getRadarObjects().end(); ++it)
-            {
-                float newdist = (*it)->getPosition().squaredDistance(shipPos);
-                if (newdist < distance)
-                {
-                    distance = newdist;
-                    it_ = it;
-                }
-            }
-
-            if (it_ != HUDRadar::getInstance().getRadarObjects().end())
-            {
-                focus_ = *it_;
-
-                // move the focused object to the begin of the list, so we will iterate through all other objects when cycling
-                HUDRadar::getInstance().getRadarObjects().erase(it_);
-                HUDRadar::getInstance().getRadarObjects().insert(HUDRadar::getInstance().getRadarObjects().begin(), focus_);
-                it_ = HUDRadar::getInstance().getRadarObjects().begin();
-            }
-        }
-        else if (it_ != HUDRadar::getInstance().getRadarObjects().end())
-        {
-            focus_->resetMaterial();
-            ++it_;
-            if (it_ != HUDRadar::getInstance().getRadarObjects().end())
-                focus_ = *it_;
-            else
-                focus_ = 0;
-        }
-        else
-        {
-            focus_ = 0;
-        }
-        updateFocus();
-    }
-
-    void HUDNavigation::updateFocus()
-    {
-        if (focus_)
-        {
-            overlay_->show();
-            focus_->setColour(ColourValue::White);
-        }
-        else
-        {
-            overlay_->hide();
-        }
-    }
-
-    void HUDNavigation::releaseFocus()
-    {
-        this->focus_ = 0;
-        this->updateFocus();
-    }
-
     float HUDNavigation::getDist2Focus() const
     {
-        if (focus_)
-            return (focus_->getPosition() - SpaceShip::getLocalShip()->getPosition()).length();
+        if (Radar::getInstance().getFocus())
+            return (Radar::getInstance().getFocus()->getWorldPosition() - SpaceShip::getLocalShip()->getPosition()).length();
         else
             return 0;
@@ -377 +314 @@
     }
 
-    /*static*/ HUDNavigation& HUDNavigation::getInstance()
+    /*static*/ /*HUDNavigation& HUDNavigation::getInstance()
     {
         assert(instance_s);
         return *instance_s;
-    }
-
-    /*static*/ void HUDNavigation::cycleNavigationFocus()
-    {
-        // avoid using getInstance because of the assert().
-        // User might call this fuction even if HUDNavigation doesn't exist.
-        if (instance_s)
-            instance_s->cycleFocus();
-    }
-
-    /*static*/ void HUDNavigation::releaseNavigationFocus()
-    {
-        // avoid using getInstance because of the assert().
-        // User might call this fuction even if HUDNavigation doesn't exist.
-        if (instance_s)
-            instance_s->releaseFocus();
-    }
+    }*/
 }

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

@@ -50 +50 @@
         void tick(float dt);
 
-        void cycleFocus();
+        //void cycleFocus();
         float getDist2Focus() const;
 
-        inline RadarObject* getFocus() const
+        /*inline RadarObject* getFocus() const
             { return this->focus_; }
-        void releaseFocus();
+        void releaseFocus();*/
 
-        static void cycleNavigationFocus();
+        /*static void cycleNavigationFocus();
         static void releaseNavigationFocus();
-        static HUDNavigation& getInstance();
+        static HUDNavigation& getInstance();*/
 
       protected:
@@ -87 +87 @@
         float aimMarkerSize_;                       //!< One paramter size of the aim marker
         Ogre::TextAreaOverlayElement* navText_;     //!< Text overlay to display the target distance
-        std::list<RadarObject*>::iterator it_;
-        RadarObject* focus_;                        // next pointer of linked list
         bool wasOutOfView_;                         //!< Performance booster variable: setMaterial is not cheap
 
-        static HUDNavigation* instance_s;
+        //static HUDNavigation* instance_s;
   };
 }

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

@@ -37 +37 @@
 #include "objects/SpaceShip.h"
 #include "objects/WorldEntity.h"
+#include "tools/TextureGenerator.h"
 #include "RadarViewable.h"
 
@@ -42 +43 @@
 {
     CreateFactory(HUDRadar);
-    CreateFactory(RadarColour);
     CreateFactory(RadarShape);
-
-    HUDRadar* HUDRadar::instance_s = 0;
 
     using namespace Ogre;
@@ -51 +49 @@
     HUDRadar::HUDRadar()
       : background_(0)
+      , marker_(0)
+      , sensitivity_(1.0f)
     {
         RegisterObject(HUDRadar);
-
-        assert(instance_s == 0);
-        instance_s = this;
     }
 
@@ -62 +59 @@
         if (this->isInitialized())
         {
-            if (this->background_)
+            /*if (this->background_)
                 OverlayManager::getSingleton().destroyOverlayElement(this->background_);
             while (this->radarDots_.size() > 0)
@@ -68 +65 @@
                 OverlayManager::getSingleton().destroyOverlayElement(this->radarDots_[this->radarDots_.size() - 1]);
                 this->radarDots_.pop_back();
-            }
-        }
-
-        instance_s = 0;
+            }*/
+        }
     }
 
@@ -78 +73 @@
         OrxonoxOverlay::XMLPort(xmlElement, mode);
 
-        XMLPortObject(HUDRadar, RadarColour, "shapes", addShape, getShape, xmlElement, mode, false, true);
+        if (mode == XMLPort::LoadObject)
+        {
+            this->sensitivity_ = 1.0f;
+            this->halfDotSizeDistance_ = 3000.0f;
+            this->maximumDotSize_ = 0.1;
+        }
+
+        XMLPortParam(HUDRadar, "sensitivity", setRadarSensitivity, getRadarSensitivity, xmlElement, mode);
+        XMLPortParam(HUDRadar, "halfDotSizeDistance", setHalfDotSizeDistance, getHalfDotSizeDistance, xmlElement, mode);
+        XMLPortParam(HUDRadar, "maximumDotSize", setMaximumDotSize, getMaximumDotSize, xmlElement, mode);
+
+        shapeMaterials_[RadarViewable::Dot]      = "RadarSquare.tga";
+        shapeMaterials_[RadarViewable::Triangle] = "RadarSquare.tga";
+        shapeMaterials_[RadarViewable::Square]   = "RadarSquare.tga";
 
         if (mode == XMLPort::LoadObject)
@@ -86 +94 @@
             overlay_->add2D(background_);
 
-            // create an array of all possible materials
-            unsigned int iMaterial = 0;
-            for (std::map<unsigned int, RadarShape*>::const_iterator itShape = shapes_.begin(); itShape != shapes_.end(); ++itShape)
-            {
-                Ogre::MaterialPtr originalMaterial = (Ogre::MaterialPtr)(Ogre::MaterialManager::getSingleton().getByName((*itShape).second->getAttribute()));
-                for (std::map<unsigned int, RadarColour*>::const_iterator itColour = colours_.begin(); itColour != colours_.end(); ++itColour)
-                {
-                    Ogre::MaterialPtr newMaterial = originalMaterial->clone((*itShape).second->getAttribute() + convertToString(iMaterial++));
-                    newMaterial->getTechnique(0)->getPass(0)->setAmbient((*itColour).second->getAttribute()); 
-                    materialNames_[(*itShape).first + ((*itColour).first << 8)] = newMaterial->getName();
-                }
-            }
-
-            /*WorldEntity* object;
-            object = new WorldEntity();
-            object->setPosition(2000.0, 0.0, 0.0);
-            addRadarObject(object, ColourValue(0.5, 0, 0, 1));
-            object = new WorldEntity();
-            object->setPosition(0.0, 2000.0, 0.0);
-            addRadarObject(object, ColourValue(0.5, 0, 0, 1));
-            object = new WorldEntity();
-            object->setPosition(0.0, 0.0, 2000.0);
-            addRadarObject(object, ColourValue(0.5, 0, 0, 1));
-            object = new WorldEntity();
-            object->setPosition(10000.0,16000.0,0.0);
-            addRadarObject(object);*/
-        }
-    }
-
-    void HUDRadar::addColour(RadarColour* colour)
-    {
-        this->colours_[colour->getIndex()] = colour;
-    }
-
-    RadarColour* HUDRadar::getColour(unsigned int index) const
-    {
-        if (index < this->colours_.size())
-        {
-            std::map<unsigned int, RadarColour*>::const_iterator it = colours_.begin();
-            for (unsigned int i = 0; i != index; ++it, ++i)
-                ;
-            return (*it).second;
-        }
-        else
-            return 0;
-    }
-
-    void HUDRadar::addShape(RadarShape* shape)
+            marker_ = (Ogre::PanelOverlayElement*)Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_Marker");
+            marker_->setMaterialName("Orxonox/RadarMarker");
+            overlay_->add2D(marker_);
+            marker_->hide();
+        }
+    }
+
+    /*void HUDRadar::addShape(RadarShape* shape)
     {
         this->shapes_[shape->getIndex()] = shape;
@@ -149 +117 @@
         else
             return 0;
-    }
-
-    void HUDRadar::tick(float dt)
+    }*/
+
+    void HUDRadar::displayObject(RadarViewable* object, bool bIsMarked)
+    {
+        const WorldEntity* wePointer = object->getWorldEntity();
+
+        // Just to be sure that we actually have a WorldEntity
+        // We could do a dynamic_cast, but that's a lot slower
+        if (!wePointer)
+        {
+            CCOUT(4) << "Cannot display a non-WorldEntitiy on the radar" << std::endl;
+            return;
+        }
+
+        /*static int counter = 0;
+        if (++counter < 1120 && counter > 120)
+        {
+            // we have to create a new entry
+            Ogre::PanelOverlayElement* panel = static_cast<Ogre::PanelOverlayElement*>(
+                Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberStr()));
+            // get right material
+            panel->setMaterialName("Orxonox/RadarSquare");
+            panel->setDimensions(0.03, 0.03);
+            panel->setPosition((1.0 + (rand() & 0xFF) / 256.0 - 0.001) * 0.5, (1.0 - (rand() & 0xFF) / 256.0 - 0.001) * 0.5);
+            panel->show();
+            this->overlay_->add2D(panel);
+            this->overlay_->show();
+        }*/
+
+        // try to find a panel already created
+        Ogre::PanelOverlayElement* panel;
+        std::map<RadarViewable*, Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.find(object);
+        if (it == this->radarDots_.end())
+        {
+            // we have to create a new entry
+            panel = static_cast<Ogre::PanelOverlayElement*>(
+                Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberStr()));
+            radarDots_[object] = panel;
+            // get right material
+            panel->setMaterialName(TextureGenerator::getMaterialName(
+                shapeMaterials_[object->getRadarObjectType()], object->getRadarObjectColour()));
+            this->overlay_->add2D(panel);
+        }
+        else
+            panel = (*it).second;
+
+        // set size to fit distance...
+        float distance = (wePointer->getWorldPosition() - SpaceShip::getLocalShip()->getPosition()).length();
+        // calculate the size with 1/distance dependency for simplicity (instead of exp(-distance * lambda)
+        float size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance);
+        panel->setDimensions(size, size);
+
+        // calc position on radar...
+        Vector2 coord = get2DViewcoordinates(SpaceShip::getLocalShip()->getPosition(), SpaceShip::getLocalShip()->getDir(), SpaceShip::getLocalShip()->getOrth(), wePointer->getWorldPosition());
+        coord *= Ogre::Math::PI / 3.5; // small adjustment to make it fit the texture
+        panel->setPosition((1.0 + coord.x - size) * 0.5, (1.0 - coord.y - size) * 0.5);
+
+        if (bIsMarked)
+        {
+            this->marker_->show();
+            this->marker_->setDimensions(size * 1.2, size * 1.2);
+            this->marker_->setPosition((1.0 + coord.x - size * 1.2) * 0.5, (1.0 - coord.y - size * 1.2) * 0.5);
+        }
+    }
+
+    void HUDRadar::radarTick(float dt)
+    {
+    }
+
+    /*void HUDRadar::tick(float dt)
     {
         // iterate through all RadarObjects
@@ -159 +194 @@
             if ((*it)->isVisibleOnRadar())
             {
-                WorldEntity* object = (*it)->getWorldEntity();
-                // Just to be sure that we actually have a WorldEntity
-                // We could do a dynamic_cast, but that's a lot slower
-                assert(object);
-
-                // set size to fit distance...
-                float size = 1.0/((object->getWorldPosition() - SpaceShip::getLocalShip()->getPosition()).length());
-                size = clamp(size * 100.0f, 0.02f, 0.12f);
-                if (i == radarDots_.size())
-                {
-                    // we have to create a new panel
-                    radarDots_.push_back(static_cast<Ogre::PanelOverlayElement*>(
-                        Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + convertToString(i))));
-                }
-                radarDots_[i]->setDimensions(size, size);
-
-                // calc position on radar...
-                Vector2 coord = get2DViewcoordinates(SpaceShip::getLocalShip()->getPosition(), SpaceShip::getLocalShip()->getDir(), SpaceShip::getLocalShip()->getOrth(), object->getWorldPosition());
-                coord *= Ogre::Math::PI / 3.5; // small adjustment to make it fit the texture
-                radarDots_[i]->setPosition((1.0 + coord.x) * 0.5, (1.0 - coord.y) * 0.5);
-
-                // apply the right material
-                RadarPoint description = (*it)->getDescription();
-                radarDots_[i]->setMaterialName(materialNames_[description.shape_ + (description.colour_ << 8)]);
             }
         }
-    }
-
-    void HUDRadar::listObjects()
+    }*/
+
+    /*void HUDRadar::listObjects()
     {
         COUT(3) << "List of RadarObjects:\n";
@@ -196 +207 @@
             COUT(3) << i++ << ": " << (*it)->getWorldEntity()->getWorldPosition() << std::endl;
         }
-    }
-
-    /*static*/ HUDRadar& HUDRadar::getInstance()
-    {
-        assert(instance_s);
-        return *instance_s;
-    }
+    }*/
 }

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

@@ -92 +92 @@
 
 
-    class _OrxonoxExport HUDRadar : public OrxonoxOverlay, public Tickable, public RadarListener
+    class _OrxonoxExport HUDRadar : public OrxonoxOverlay, public RadarListener//, public Tickable
     {
       public:
@@ -100 +100 @@
         void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
-        void addShape(RadarShape* shape);
-        RadarShape* getShape(unsigned int index) const;
+        /*void addShape(RadarShape* shape);
+        RadarShape* getShape(unsigned int index) const;*/
 
-        void tick(float dt);
+        float getRadarSensitivity() const { return this->sensitivity_; }
+        void setRadarSensitivity(float sensitivity) { this->sensitivity_ = sensitivity; }
 
-        void listObjects();
+        float getHalfDotSizeDistance() const { return this->halfDotSizeDistance_; }
+        void setHalfDotSizeDistance(float distance) { this->halfDotSizeDistance_ = distance; }
+
+        float getMaximumDotSize() const { return this->maximumDotSize_; }
+        void setMaximumDotSize(float size) { this->maximumDotSize_ = size; }
+
+        //void tick(float dt);
+
+        //void listObjects();
 
       private:
-        void addColour(RadarColour* colour);
-        RadarColour* getColour(unsigned int index) const;
+        void displayObject(RadarViewable* viewable, bool bIsMarked);
+        void hideMarker() { this->marker_->hide(); }
+        float getRadarSensitivity() { return 1.0f; }
+        void radarTick(float dt);
 
-        std::map<unsigned int, std::string> materialNames_;
-        std::map<unsigned int, RadarColour*> colours_;
-        std::map<unsigned int, RadarShape*> shapes_;
+        std::map<RadarViewable::Shape, std::string> shapeMaterials_;
 
         Ogre::PanelOverlayElement* background_;
         std::map<RadarViewable*, Ogre::PanelOverlayElement*> radarDots_;
+        Ogre::PanelOverlayElement* marker_;
+
+        float halfDotSizeDistance_;
+        float maximumDotSize_;
+
+        float sensitivity_;
     };
 }

code/branches/hud/src/orxonox/tools/TextureGenerator.cc

@@ -77 +77 @@
             textureUnitState->setTextureName(textureName);
             textureUnitState->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, colour);
-            colourMap[colour] = materialName;
-            return colourMap[colour];
+            return (colourMap[colour] = materialName);
         }
         else

code/branches/hud/visual_studio/vc8/orxonox.vcproj

@@ -189 +189 @@
                         </File>
                         <File
+                                RelativePath="..\..\src\orxonox\RadarViewable.cc"
+                                >
+                                <FileConfiguration
+                                        Name="Debug|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                ObjectFile="$(IntDir)\$(InputName)1.obj"
+                                                XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
+                                        />
+                                </FileConfiguration>
+                                <FileConfiguration
+                                        Name="Release|Win32"
+                                        >
+                                        <Tool
+                                                Name="VCCLCompilerTool"
+                                                ObjectFile="$(IntDir)\$(InputName)1.obj"
+                                                XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
+                                        />
+                                </FileConfiguration>
+                        </File>
+                        <File
                                 RelativePath="..\..\src\orxonox\Settings.cc"
                                 >
@@ -484 +506 @@
                                         <File
                                                 RelativePath="..\..\src\orxonox\overlays\hud\HUDText.cc"
-                                                >
-                                        </File>
-                                        <File
-                                                RelativePath="..\..\src\orxonox\overlays\hud\RadarObject.cc"
-                                                >
-                                        </File>
-                                        <File
-                                                RelativePath="..\..\src\orxonox\overlays\hud\RadarViewable.cc"
                                                 >
                                         </File>
@@ -523 +537 @@
                         </File>
                         <File
+                                RelativePath="..\..\src\orxonox\RadarViewable.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\orxonox\Settings.h"
                                 >
@@ -698 +716 @@
                                         <File
                                                 RelativePath="..\..\src\orxonox\overlays\hud\HUDText.h"
-                                                >
-                                        </File>
-                                        <File
-                                                RelativePath="..\..\src\orxonox\overlays\hud\OverlayElementFactories.h"
-                                                >
-                                        </File>
-                                        <File
-                                                RelativePath="..\..\src\orxonox\overlays\hud\RadarObject.h"
-                                                >
-                                        </File>
-                                        <File
-                                                RelativePath="..\..\src\orxonox\overlays\hud\RadarViewable.h"
                                                 >
                                         </File>