backendLineOfSightManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2018 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once


#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/vrfExtendedIntervisibilitySettings.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtSelectionManager.h>
#include <vlutil/vlString.h>
#include <matrix/vlVector.h>
#include <vlutil/vlPerformanceStats.h>
#include <vrfmsgs/ifIntersectionInformationResponse.h>
#include <vrfutil/rwUUID.h>

#include <vlpi/simulationAddress.h>

namespace makVrv
{
   class DtDe;
   class DtIntervisibilityStateListener;
   class DtIntervisibilityElement;
}

class DtSimMessage;

namespace makVrf
{
   class DtVrfSimBackendManager;
   class DtIntervisibilityOptionExtensions;

   class DT_DLL_VRFGUICORE DtBackendLineOfSightManager : public makVrv::DtVirtualBaseClass
   {
   public:
      DtBackendLineOfSightManager(makVrv::DtDe&);

      virtual ~DtBackendLineOfSightManager() override;

      static DtBackendLineOfSightManager& instance(makVrv::DtDe& de);
      static void registerInstance(makVrv::DtDe& de, DtBackendLineOfSightManager*);

      virtual bool hasRequestPending(makVrv::DtUniqueID) const;

      virtual void requestLineOfSightCheck(makVrv::DtUniqueID, const DtVector& start, const DtVector& end,
         bool intersectTerrain = true, bool intersectEntities = false, bool intersectFeatures = true);

      struct LineOfSightPoint
      {
         LineOfSightPoint(const DtVector& s, const DtVector& e, const DtString& u = "") :
            start(s), end(e), userData(u) {};
         LineOfSightPoint(const LineOfSightPoint& orig) : start(orig.start), end(orig.end), userData(orig.userData) {};

         DtVector start;
         DtVector end;
         DtString userData;
      };

      typedef std::vector<LineOfSightPoint> LineOfSightPoints;

      virtual void requestLineOfSightCheck(makVrv::DtUniqueID, const LineOfSightPoints& pts,
         bool intersectTerrain = true, bool intersectEntities = false, bool intersectFeatures = true);

      virtual void addReference(makVrv::DtUniqueID);
      virtual void removeReference(makVrv::DtUniqueID);

      virtual bool validBackendToCheck() const;

      boost::signals2::signal<void (makVrv::DtUniqueID, const DtIfIntersectionInformationResponse::IntersectionPairInformation&)> signal_lineOfSightResponse;

      boost::signals2::signal<void (makVrv::DtUniqueID, DtVrfExtendedIntervisibilitySettingsData::IntervisibilitySettings)> signal_extendedIntervisibilityOptionsChanged;

      virtual bool needsRequestForBackendLineOfSight(makVrv::DtUniqueID id, const DtVector& startPoint, const DtVector& endPoint,
         double waitTimeRequest, bool intersectEntities, bool& startingTimeRequest, bool useAsTimer = false);

      virtual void setAlphaFactor(double);
      virtual double alphaFactor() const;

      typedef DtVrfExtendedIntervisibilitySettingsData::Color Color;

      virtual void adjustAlpha(makVrv::DtUniqueID, double alpha);
      virtual void adjustColor(makVrv::DtUniqueID, const Color& visible, const Color& blocked);

      virtual bool itemIsSelected(makVrv::DtUniqueID) const;

   protected:
      virtual void checkWaitingForColor();

      virtual void slot_visibleColorChanged(makVrv::DtUniqueID, float, float, float, float);
      virtual void slot_blockedColorChanged(makVrv::DtUniqueID, float, float, float, float);

      virtual void slot_extendedIntervisibilityOptionsChanged(makVrv::DtUniqueID id, DtVrfExtendedIntervisibilitySettingsData::IntervisibilitySettings);

      virtual DtVrfSimBackendManager& backendManager() const;
      virtual void removeRequestId(makVrv::DtUniqueID);
      virtual void processIntersectionResponse(DtSimMessage*);

      virtual void resetColor(makVrv::DtUniqueID, const Color& visibleColor, const Color& blockedColor);

      virtual void slot_onCurrentSelectionChanged(const makVrv::DtSelectionManager::IdSet& deselected);

      virtual void setupConnectionsForListener(makVrv::DtIntervisibilityStateListener*, makVrv::DtSignalConnectionManager*);

      virtual void slot_elementToBeDestroyed(makVrv::DtIntervisibilityElement*);

   protected:
      makVrv::DtDe& myDe;
      mutable DtVrfSimBackendManager* myBackendManager;

      std::map<makVrv::DtUniqueID, unsigned long> myKeyToRequestMap;
      std::map<unsigned long, std::pair<makVrv::DtUniqueID, DtSimulationAddress> > myRequestToKeyMap;

      struct UpdateCheckState
      {
         UpdateCheckState() : timingBackendRequest(false), elapsedTimeCheck(0.), refCount(0), listener(0),
            lengthOfTimeForBackendResponse(0.), connections(0), optExt(0), alphaFactor(1.0)
         {
         }

         UpdateCheckState(const UpdateCheckState& orig) : timingBackendRequest(orig.timingBackendRequest), elapsedTimeCheck(orig.elapsedTimeCheck),
            startPoint(orig.startPoint), endPoint(orig.endPoint), refCount(orig.refCount), listener(orig.listener),
            lengthOfTimeForBackendResponse(orig.lengthOfTimeForBackendResponse),
            connections(orig.connections), optExt(orig.optExt), blockedColor(orig.blockedColor), visibleColor(orig.visibleColor),
            currentBlockedColor(orig.currentBlockedColor), currentVisibleColor(orig.currentVisibleColor), alphaFactor(orig.alphaFactor)
         {
         }

         virtual ~UpdateCheckState()
         {
            delete connections;
         }

         DtIntervisibilityOptionExtensions* optExt;
         bool timingBackendRequest;
         double elapsedTimeCheck;
         DtTimedSection timedSection;
         DtVector startPoint;
         DtVector endPoint;
         int refCount;
         makVrv::DtIntervisibilityStateListener* listener;
         makVrv::DtSignalConnectionManager* connections;

         Color blockedColor;
         Color currentBlockedColor;
         double alphaFactor;

         Color visibleColor;
         Color currentVisibleColor;

         DtTimedSection backendRequestTimer;
         double lengthOfTimeForBackendResponse;
      };

      std::map<makVrv::DtUniqueID, UpdateCheckState> myUpdateCheckState;
      makVrv::DtSignalConnectionManager myConnections;
      boost::signals2::connection mySelectionChangedConnection;

      double myAlphaFactor;

      struct ColorWait
      {
         ColorWait() {};
         ColorWait(const Color& v, const Color& b) : visibleColor(v), blockedColor(b) {};
         ColorWait(const ColorWait& orig) : visibleColor(orig.visibleColor), blockedColor(orig.blockedColor) {};

         Color visibleColor, blockedColor;
      };
      
      std::map<makVrv::DtUniqueID, ColorWait> myWaitForSelectionChange;
   };
}