DtVrlinkBoxVisualizers.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/Dt2DBoxVisualizer.h>
#include <vrvCore/Dt3DBoxVisualizer.h>
#include <vrvCore/DtAreaFacadeBase.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 DtVrlinkBoxVisualizer : public T
      {
      public:
         DtVrlinkBoxVisualizer(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(
               &DtVrlinkBoxVisualizer<T>::resetSpatial,
               this ) ) );

            if (this->myTacticalGraphicStateListener)
            {
               this->myConnections.manageConnection(myTacticalGraphicStateListener->signal_hostGlobalIdSet.connect(
                  boost::bind(&DtVrlinkBoxVisualizer::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 ~DtVrlinkBoxVisualizer()
         {
            DtEntityExistenceListener::instance(myVrlinkConnection).signal_entityDiscovered.disconnect(
               boost::bind(&DtVrlinkBoxVisualizer::slot_entityCreated, this, _1));
         }

         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(&DtVrlinkBoxVisualizer::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(&DtVrlinkBoxVisualizer::slot_entityCreated, this, _1));
               return;
            }

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

         virtual void setOrigin(const DtVector& v)
         {
            DtVector local;

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

            T::setOrigin(local);
         }

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

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

            T::addPoint(index, local);
         }

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

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

            T::modifyPoint(index, local);
         }

         virtual void setPoints(
            const DtEnvironmentalStateListener::ControlPointsList& v)
         {
            DtEnvironmentalStateListener::ControlPointsList locals(v);

            if (!this->myAttachedFlag)
            {
               DtEnvironmentalStateListener::ControlPointsList::iterator w = locals.begin();

               DtEnvironmentalStateListener::ControlPointsList::const_iterator i = v.begin();
               DtEnvironmentalStateListener::ControlPointsList::const_iterator e = v.end();
               for(;i != e;++i,++w)
               {
                  myVrlinkConnection.coordinateSystem().netToLocalPos(*i,*w);
               }
            }

            if ( this->myAreaFacade && !this->myAttachedUpdaterAgent)
            {
               this->myAreaFacade->resetOrigin();
            }

            T::setPoints(locals);      
         }

      protected:

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

         void setupArea(DtAreaFacadeBase* f)
         {
            T::setupArea(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->myAreaFacade)
            {
               this->myAreaFacade->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<DtVrlinkBoxVisualizer<Dt2DBoxVisualizer> >
         DtVrlink2DBoxVisualizerCreator;

      typedef DtStateVisualizerCreatorTemplate<DtVrlinkBoxVisualizer<Dt3DBoxVisualizer> >
         DtVrlink3DBoxVisualizerCreator;
   }
}