simComponent.h

Go to the documentation of this file.

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


#pragma once

#include <vrfobjcore/vrfobjcoreDefines.h>
#include <vrfobjcore/simComponentFactory.h>
#include <vrfobjcore/localObject.h>

#include <vrfStateData/taskVisualizationForwards.h>
#include <vrfcore/simulationServices.h>
#include <readerWriter/readerWriter.h>

//#include <vrfutil/objectConsole.h>
#include <vrfutil/vrf4XAPI.h>

#include <vlutil/vlHashlist.h>
#include <vlutil/vlString.h>
#include <vlutil/vlList.h>

#include <list>

class DtComponentDescriptor;
class DtInputPort;
class DtOutputPort;
class DtInputPortGroup;
class DtOutputPortGroup;
class DtPhysicalWorld;
class Coordinate_System;
class DtComponentSystem;
class DtVrfProcessStateRepositoryManager;
class DtSimResourceManager;
class DtVrfProcessStateRepository;
class DtLocalObject;
class DtSimObject;
class DtSimulationServices;
class DtSimMessage;
class DtAttachedTerrain;
class DtPropertyInterface;
class DtPredicateCallbackManager;
class DtVrfObjectPredicateEvaluator;
class DtVrfObjectPredicate;
class DtTimedTickLogic;

typedef void (*DtVrfObjectPredicateCallbackFunction)(
   DtSimObjectReference obj, DtVrfObjectPredicateEvaluator* predicateEval,
   void* userData);

#define CACHED_NEXT_FRAME_STATE_PROPERTY(property) \
   DtPropertyInterface* myNextFrame##property = 0;
#define SET_CACHED_STATE_PROPERTY(property, value) \
   setCachedNextFrameStatePropertyValue(&myNextFrame##property, #property, value);

#define CACHED_CURRENT_FRAME_STATE_PROPERTY(property) \
   const DtPropertyInterface* myCurrFrame##property = 0;
#define GET_CACHED_STATE_PROPERTY_VALUE(property, value) \
   getCachedCurrentFrameStatePropertyValue(&myCurrFrame##property, #property, value);
   
      

class DT_DLL_vrfobjcore DtSimComponent : public DtReaderWriter
#ifdef DtObjectDebugger_Enable
   , public DtObjectDebugger<DtSimComponent>
#endif
{
public:

   DtSimComponent(const DtString& name,
      DtLocalObject* owner,
      DtSimulationServices* simServices,
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtSimComponent() override;

   virtual void setParentSystem(DtComponentSystem* system);
   DtComponentSystem * parentSystem() const;

   virtual bool init();

   virtual bool postAddComponentsInit() { return true; }

   virtual void registerAttributeFunctions(){}

   virtual void enable();
   virtual void disable();
   virtual bool isEnabled();
   virtual void setIsEnabled(bool yesNo);

   virtual void preFirstTickInit();

   virtual void tick();

   virtual void postTick();

   virtual void timedTick();

   virtual void setMinTickPeriod(double minTickPeriod, double minTickPeriodVariance);

   virtual void setupFirstTickTime();

   virtual const char* type() const = 0;

   virtual void setEntity(DtLocalObject* entity);

   virtual DtSimComponent* nextComponent();
   virtual DtSimComponent* prevComponent();

   virtual void setListItem(DtListItem* item);
   virtual DtListItem* listItem();

   virtual void putData(std::string& fp, int indentLevel = 0) override;

   virtual DtlObjPtr getData(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings) override;

   virtual void addInputPort(DtInputPort* port);
   virtual void removeInputPort(DtInputPort* port);

   virtual DtInputPort* lookupInputPort(const DtString& portName);

   virtual DtList inputPortList() const;

   virtual void addOutputPort(DtOutputPort* port);
   virtual void removeOutputPort(DtOutputPort* port);

   virtual DtOutputPort* lookupOutputPort(const DtString& portName);

   virtual DtList outputPortList() const;

   virtual void addInputPortGroup(DtInputPortGroup* group);
   virtual void removeInputPortGroup(DtInputPortGroup* group);

   virtual DtInputPortGroup* lookupInputPortGroup(const DtString& groupName);

   virtual DtList inputPortGroupList() const;

   virtual void addOutputPortGroup(DtOutputPortGroup* group);
   virtual void removeOutputPortGroup(DtOutputPortGroup* group);

   virtual DtOutputPortGroup* lookupOutputPortGroup(const DtString& groupName);

   virtual DtList outputPortGroupList() const;

   virtual int priority() const;
   virtual void setPriority(int priority);

   double dT() const;

   virtual void setDT(double deltaT);

   virtual void setComponentDescriptor(DtComponentDescriptor* componentDescriptor);
   virtual const DtComponentDescriptor* componentDescriptor() const;

   virtual bool tickWhileDestroyed() const;

   virtual DtOutputStream& objectConsoleDebug(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleVerbose(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleInfo(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleWarn(const DtString& channel = "") const;
   virtual DtOutputStream& objectConsoleError(const DtString& channel = "") const;
   virtual int notifyLevel() const;

   DtVrfProcessStateRepositoryManager* psrManager();


   virtual DtSimResourceManager& resourceManager();
   virtual const DtSimResourceManager& resourceManager() const;

   virtual const DtSymbolString& componentFullName() const;

   static DtSimComponentFactory* factory();
   static void setFactory(DtSimComponentFactory* factory);

   static DtSimComponent* createComponent(const DtString& name,
      const DtString& type, DtLocalObject* owner, DtSimulationServices* simManager,      DtComponentSystem* parentSystem,
      DtComponentDescriptor* desc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   static void addSimComponentCreatorFcn(const DtString& type,
      DtSimComponentCreatorFcn fcn);

   DtPhysicalWorld* physicalWorld();
   const DtPhysicalWorld* physicalWorld() const;

   const DtAttachedTerrain* terrainAttachedTo() const;

   DtLocalObject* entity() { return myEntity; }
   const DtLocalObject* entity() const { return myEntity; };

   DtSimulationServices* simulationServices();
   const DtSimulationServices* simulationServices() const;

   const Coordinate_System* coordinateSystem() const;

   virtual void isClutterChanged();

   virtual bool taskVisualizationsActive() const;

   virtual bool taskVisualizationsEnabled() const;

   virtual void onRestore();

   makVrf::DtTaskVisualizationMap& taskVisualizations()
   {
      return myTaskVisualizations;
   }

   virtual void updateImgui();

   virtual bool debugActive() const;

protected:

   virtual void setupTimedTickLogic(double minTickPeriod, double minTickPeriodVariance);

   virtual double computeCurrentTime();

   bool testInvariant() const;

   virtual bool createPortGroups();

   virtual bool createPorts();

   DtVrfProcessStateRepository* createComponentPsr(const DtString& defaultPsrType,
      const DtString& defaultPsrName, bool useDescriptorParams = true);

   virtual void updateTaskVisualizations() {};

   virtual void destroyTaskVisualizations();

   virtual void destroyTaskVisualization(const DtString& name);

   virtual makVrf::DtPointTaskVisualizationPtr pointTaskVisualization(const DtString& name);

   virtual makVrf::DtLineTaskVisualizationPtr lineTaskVisualization(const DtString& name);

   virtual makVrf::DtAreaTaskVisualizationPtr areaTaskVisualization(const DtString& name);

   virtual makVrf::DtTextTaskVisualizationPtr textTaskVisualization(const DtString& name);

   double calculateNextTaskVisTickTime() const;

   DtVrfObjectStateRepository* localStateRepository();

   const DtVrfObjectStateRepository* localStateRepository() const;

   inline DtPropertyInterface* cachedNextFrameStateProperty(DtPropertyInterface** prop, const DtString& propName);

   template<typename ValType>
   inline void setCachedNextFrameStatePropertyValue(DtPropertyInterface** prop, const DtString& propName, ValType value);

   inline const DtPropertyInterface* cachedCurrentFrameStateProperty(const DtPropertyInterface** prop, const DtString& propName) const;

   template<typename ValType>
   bool getCachedCurrentFrameStatePropertyValue(const DtPropertyInterface** prop, const DtString& propName, ValType& value) const;


   void addSimObjectPredicateCallback(DtSimObjectReference,
      DtVrfObjectPredicateCallbackFunction function,
      const DtVrfObjectPredicate& predicate, DtTime evaluationPeriod = 0,
      void* userData = 0);
   void removeSimObjectPredicateCallback(const DtSimObject*,
      DtVrfObjectPredicateCallbackFunction function,
      const DtVrfObjectPredicate& predicate, DtTime evaluationPeriod = 0,
      void* userData = 0);

   void invokeSimObjectPredicateCallbacks();

   virtual void clearPredicateCallbacks();

private:
   DtSimComponent();

   DtSimComponent(const DtSimComponent& orig);

   DtSimComponent& operator=(const DtSimComponent& orig);

protected:
   DtLocalObject*                  myEntity;

   DtComponentSystem*            mySystem;
   DtListItem*                   myListItem;

   typedef std::map<DtString, DtInputPort*> DtInputPortMap;
   typedef std::map<DtString, DtOutputPort*> DtOutputPortMap;
   typedef std::map<DtString, DtInputPortGroup*> DtInputPortGroupMap;
   typedef std::map<DtString, DtOutputPortGroup*> DtOutputPortGroupMap;

   DtInputPortMap myInputPortList;
   DtOutputPortMap myOutputPortList;
   DtInputPortGroupMap myInputPortGroupList;
   DtOutputPortGroupMap myOutputPortGroupList;

   static DtSimComponentFactory* myFactory;

   int                           myPriority;

   double myLastTickSimTime;
   std::unique_ptr<DtTimedTickLogic> myTimedTickLogic;
   double myDT;

   bool myIsEnabled;

   bool myFirstTick;

   const DtComponentDescriptor* myComponentDescriptor;

   std::list<DtVrfProcessStateRepository*> myComponentPsrs;

   makVrf::DtTaskVisualizationMap myTaskVisualizations;

   double myNextTaskVisTickTime;

   mutable DtSymbolString myFullComponentName;

   DtSimulationServices* mySimServices;
   DtPredicateCallbackManager* myPredicateCallbackManager;

   boost::signals2::scoped_connection myIsClutterChangedConnection;

   bool myLocalDebug;

public:

   VRF4API_METHOD const DtSimulationServices* simManager() const { return simulationServices(); };
   VRF4API_METHOD static DtSimComponent* MarkThreadSafe(DtSimComponent* comp) { return comp; };
};

inline double DtSimComponent::dT() const
{
   return myDT;
}

inline DtPropertyInterface* DtSimComponent::cachedNextFrameStateProperty(DtPropertyInterface** prop, const DtString& propName)
{
   if (!*prop)
   {
      *prop = entity()->nextFrameStateProperties().findPropertyInterface(propName);
   }

   return *prop;
}

template<typename ValType>
inline void DtSimComponent::setCachedNextFrameStatePropertyValue(DtPropertyInterface** prop, const DtString& propName, ValType value)
{
   DtPropertyInterface* propIf = cachedNextFrameStateProperty(prop, propName);
   if (propIf)
   {
      propIf->setPropertyValue(value);
   }
}

inline const DtPropertyInterface* DtSimComponent::cachedCurrentFrameStateProperty(const DtPropertyInterface** prop, const DtString& propName) const
{
   if (!*prop)
   {
      *prop = entity()->stateProperties().findPropertyInterface(propName);
   }

   return *prop;
}

template<typename ValType>
bool DtSimComponent::getCachedCurrentFrameStatePropertyValue(const DtPropertyInterface** prop, const DtString& propName, ValType& value) const
{
   const DtPropertyInterface* propIf = cachedCurrentFrameStateProperty(prop, propName);
   if (propIf)
   {
      auto propVal = propIf->propertyValue<ValType>();
      if (propVal)
      {
         value = *propVal;
         return true;
      }
   }
   else
   {
      objectConsoleWarn() << "Could not find state property: " << propName << std::endl;
   }

   return false;
}

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtSimComponent);