DtForceManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h> 
#include <vrvCore/DtSharedSettings.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/event_signal.h>

#include <vlpi/disEnums.h>

#include <vector>
#include <map>

namespace makVrv
{

   class DtSharedSettingsManager;

#define FRIENDLY_COLOR .5f,224.f / 255.f, 1.f ,0.8f
#define FRIENDLY_PRIMARY_COLOR 0.f, 0.f, 1.f, 0.8f
#define OPPOSING_COLOR 1.f,.5f,.5f,0.8f
#define OPPOSING_PRIMARY_COLOR 1.f, 0.f, 0.f, 0.8f
#define NEUTRAL_COLOR 170.f / 255.f,1.f, 170.f / 255.f,0.8f
#define NEUTRAL_PRIMARY_COLOR 0.f, 1.f, 0.f, 0.8f
#define UNKNOWN_COLOR 1.f, 1.f, .5f, 0.8f
#define UNKNOWN_PRIMARY_COLOR 1.f, 1.f, 0.f, 0.8f
   
   class DT_DLL_VRVCORE DtForceManager : public DtSharedSettings
   {
   public:

      struct RGBAColor
      {
         RGBAColor(float r, float g, float b, float a)
         : R(r), G(g), B(b), A(a)
         {
         }

         RGBAColor()
         : R(0.f), G(0.f), B(0.f), A(0.f)
         {
         }

         float R, G, B, A;
      };

   public:

      DtForceManager(DtSharedSettingsManager& manager);

      virtual ~DtForceManager();

      DtForceManager() = delete;

      DtForceManager(const DtForceManager&) = delete;

      DtForceManager& operator=(const DtForceManager&) = delete;

   public:

      static const std::string& className();

      virtual void addForce(DtForceType force, const std::string& forceName, 
         const RGBAColor& forceColor, const RGBAColor& forcePrimaryColor,
         bool includeInDialogs = true);

      virtual void removeForce(DtForceType);

      virtual int numForces() const;

      virtual DtForceType forceAt(int iIndex) const;
      
      virtual RGBAColor colorForForce(DtForceType force, 
         bool usePrimaryColors=false) const;

      virtual std::string nameForForce(DtForceType force) const;
      
      virtual DtForceType forceFromName(const std::string& name) const;

      virtual bool includeInDialogs(DtForceType force) const;

      // Used by the entity editor
      virtual void setHostility(DtU8 force, DtU8 targetForce, bool hostile);
      virtual bool hostile(DtU8 force, DtU8 targetForce);

      virtual void clearForces();

   protected:

      struct ForceInfo
      {
         std::string       myForceName;
         RGBAColor         myForceColor;
         RGBAColor         myForcePrimaryColor;
         bool              myIncludeInDialogs;
         std::vector<int>  myHostilityList;
      };

      // Information for a specific force
      virtual const ForceInfo& forceInformation(DtForceType force) const;
      virtual ForceInfo& forceInformation(DtForceType force);


      ForceInfo myNullForce;
      std::map<DtForceType, ForceInfo>  myForces;
   };

   class DT_DLL_VRVCORE DtSharedForceManagerSignaler : public DtVirtualBaseClass
   {
   public:

      virtual ~DtSharedForceManagerSignaler();

      DtSharedForceManagerSignaler() = delete;

      DtSharedForceManagerSignaler(const DtSharedForceManagerSignaler&) = delete;

      DtSharedForceManagerSignaler& operator=(const DtSharedForceManagerSignaler&) = delete;
   
   protected:

      DtSharedForceManagerSignaler(DtEventQueueInterface& eqi);

   public:

      static DtSharedForceManagerSignaler&
         instance( const DtSharedSettingsManager& mgr );

      static DtSharedForceManagerSignaler&
         instance( DtEventQueueInterface& eqi );

      static DtSharedForceManagerSignaler*
         findInstance( DtEventQueueInterface* eqi );


      event_signal<void (int)> signal_forceRemoved;

      event_signal<void (int)> signal_forceAdded;


   };
}