DtVrlinkEllipseVisualizers.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2015 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once

#include <vrvVrl/vrvVrl.h>
#include <vrvCore/Dt2DEllipseVisualizer.h>
#include <vrvCore/Dt3DEllipseVisualizer.h>
#include <vrvCore/DtEllipseFacadeBase.h>
#include <vrvVrl/DtEntityExistenceListener.h>
#include <vrvVrl/DtEntityElementProcessor.h>
#include <vrvVrl/DtVrlinkTacticalGraphicStateListener.h>

#include <vrvUtil/DtCoordinateSystem.h>
#include <vrvVrl/DtVrlinkConnection.h>

#include <matrix/topoCoord.h>

namespace makVrv
{
   namespace DT_PROTOCOL_NAMESPACE
   {
      template <typename T>
      class DtVrlinkEllipseVisualizer : public T
      {
      public:
         DtVrlinkEllipseVisualizer(DtBaseConnection& simulation, DtStateListener& listener,
            int modelSet)
         : T(simulation, listener, modelSet)
         , myVrlinkConnection((dynamic_cast<DtVrlinkConnection&>(simulation)))
         , myTacticalGraphicStateListener(dynamic_cast<DtVrlinkTacticalGraphicStateListener*>(&listener))
         {
            this->myConnections.manageConnection(
               myVrlinkConnection.signal_coordinateSystemChanged.connect( boost::bind(
               &DtVrlinkEllipseVisualizer::resetSpatial,
               this ) ) );

            if (this->myTacticalGraphicStateListener)
            {
               this->myConnections.manageConnection(myTacticalGraphicStateListener->signal_hostGlobalIdSet.connect(
                  boost::bind(&DtVrlinkEllipseVisualizer::setHostGlobalId,this,_1)));

               if(this->myTacticalGraphicStateListener->cosr().hostGlobalId() != DtGlobalObjectDesignator())
               {
                  this->setHostGlobalId(this->myTacticalGraphicStateListener->cosr().hostGlobalId().string());

                  if (this->myAttachedFlag)
                  {
                     this->setRelativeLocation(this->myTacticalGraphicStateListener->relativeLocation());
                     this->setOffsetPoints(this->myTacticalGraphicStateListener->offsetPoints());
                  }
               }
            }
         }

         virtual ~DtVrlinkEllipseVisualizer()
         {
            DtEntityExistenceListener::instance(myVrlinkConnection).signal_entityDiscovered.disconnect(
               boost::bind(&DtVrlinkEllipseVisualizer::slot_entityCreated, this, _1));
         }

         void setPosition(int index, const DtVector& v)
         {
            DtVector local;

            myVrlinkConnection.coordinateSystem().netToLocalPos(v, local);

            T::setPosition(index, local);
         }

         void setColor(float r, float g, float b, float a)
         {
            if ((r == 0) && (g == 0) && (b == 0))
            {
               this->useDefaultColor();
            }
            else
            {
               T::setColor(r, g, b, a);
            }
         }

         void setHostGlobalId(const std::string& id)
         {
            // Make sure no previous setHostGlobalId calls leave connections to the
            // entity listener lying around
            DtEntityExistenceListener::instance(myVrlinkConnection).signal_entityDiscovered.disconnect(
               boost::bind(&DtVrlinkEllipseVisualizer::slot_entityCreated, this, _1));

            this->myHostToBeCreated = DtGlobalObjectDesignator(id.c_str());

            if(id.empty() || id == "0:0:0")
            {
               if(this->myAttachedFlag)
               {
                  this->setAttached(0);
               }
               return;
            }

            DtEntityElementProcessor* entityVis = DtEntityElementProcessor::findInstance(myVrlinkConnection);
            DtEntityVisualizerSet* hostVis = entityVis->findVisualizerSet(DtGlobalObjectDesignator(id.c_str()), this->myModelSet);         
            //If the host does not yet exist.
            if (!hostVis)
            {
               //Disembark from current.
               if (this->myAttachedFlag)
               {
                  this->setAttached(0);
               }
               //Setup value to wait.
               DtEntityExistenceListener::instance(myVrlinkConnection).signal_entityDiscovered.connect(
                  boost::bind(&DtVrlinkEllipseVisualizer::slot_entityCreated, this, _1));
               return;
            }

            // The entity is embarking on an entity that's been created
            this->setAttached(hostVis->uniqueID());
         }

      protected:

         void slot_entityCreated(DtVrlinkEntityStateListener& esl)
         {
            if (esl.esr().globalId() == myHostToBeCreated)
            {
               DtEntityExistenceListener::instance(myVrlinkConnection).signal_entityDiscovered.disconnect(
                  boost::bind(&DtVrlinkEllipseVisualizer::slot_entityCreated, this, _1));
               setHostGlobalId(this->myHostToBeCreated.string());
            }
         }

         void setupEllipse(DtEllipseFacadeBase* f)
         {
            T::setupEllipse(f);

            if (this->myAttachedFlag)
            {
               this->myOffsetPoints.clear();
               this->myRelativeLocation = DtVector::zero();

               this->setRelativeLocation(this->myTacticalGraphicStateListener->relativeLocation());
               this->setOffsetPoints(this->myTacticalGraphicStateListener->offsetPoints());
            }
         }

         void endAttached()
         {
            T::endAttached();
            this->myOffsetPoints.clear();
         }

         void startAttached()
         {
            T::startAttached();

            this->myOffsetPoints.clear();

            if (this->myEllipse)
            {
               this->myEllipse->setOrigin(DtVector::zero());
            }

            if (this->myTacticalGraphicStateListener)
            {
               this->setRelativeLocation(this->myTacticalGraphicStateListener->relativeLocation());
               this->setOffsetPoints(this->myTacticalGraphicStateListener->offsetPoints());
            }
         }

      protected:
         DtVrlinkConnection& myVrlinkConnection;
         DtVrlinkTacticalGraphicStateListener* myTacticalGraphicStateListener;
         std::vector<DtVector> myOffsetPoints;
         DtGlobalObjectDesignator myHostToBeCreated;
      };

      // @{
      typedef DtStateVisualizerCreatorTemplate<DtVrlinkEllipseVisualizer<Dt3DEllipseVisualizer> >
         DtVrlink3DEllipseVisualizerCreator;
      typedef DtStateVisualizerCreatorTemplate<DtVrlinkEllipseVisualizer<Dt2DEllipseVisualizer> >
         DtVrlink2DEllipseVisualizerCreator;
      // @}
   }
}