cigiPublisherBase.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once
 
#include "vreCigiHost/export.h"
#include "vreCigiHost/cigiObjectBase.h"
 
#include "vreUtil/treeClass.h"
 
#include <CigiOutgoingMsg.h>
 
#include <memory>
#include <string>
 
namespace makVre
{
 
//! @brief Base class for CIGI Publishers
//!
//!   Publishers manage updating CIGI data, tracking dirty state, and writing to CigiOutgoingMsg when values have
//!   changed. Publishers can be parented to other Publishers, and parent Publishers init, tick, and publish their
//!   children.
class CIGIHOST_DLL DtCigiPublisherBase
   : public DtSpSubClass<DtCigiPublisherBase, DtTreeClass<DtCigiPublisherBase, DtCigiObjectBase>>
{
public:
   DtCigiPublisherBase();
   virtual ~DtCigiPublisherBase() override {};
 
   //! @brief Get pointer to shared CIGI packet data object
   //!
   //!   Shared data allows Publishers in different Sessions publishing data for the same
   //!   Sim entity to share common data which only needs to be updated once per Sim frame.
   DtCigiDataBase* shared();
   DtCigiDataBase* const shared() const;
 
   virtual bool init() override;
 
   //! @brief Enable or disable this Publisher
   //!
   //!   Tick and publish are suppressed when disabled.
   virtual void setEnabled(bool enabled);
   virtual bool enabled() const;
 
   virtual void tick(double dt);
 
   //! @brief Convenience wrapper for creating, naming, and adding a child Publisher instance
   //! of type CHILD_T.
   //!
   //! @return Shared pointer to new child Publisher object.
   template <class CHILD_T>
   std::shared_ptr<CHILD_T> addNewChild(const std::string& name = "")
   {
      std::shared_ptr<CHILD_T> ptr = CHILD_T::createVersion(sessionVersion());
      ptr->setName(name);
      addChild(ptr);
      return ptr;
   }
 
   //! @brief Adds publisher as child of this Publisher.
   //!
   //!   Child will be re-parented to this. Publishers may have only one parent.
   //!
   //! @param child Pointer to Publisher to add as child.
   //! @return Bool indicating success.
   virtual bool addChild(Sptr child) override;
 
   //! @brief Causes this Publisher to write CIGI packet data to out.
   //!
   //!   Invokes updateCigi() to make sure data is fresh and determine dirty state
   //!   if not already dirty, then invokes write() to write data to CigiOutoingMsg
   //!   if state is dirty.
   //!
   //! @param out CigiOutgoingMsg to write CIGI packet data into.
   virtual void publish(CigiOutgoingMsg& out);
 
   //! @brief Set/get whether this Publisher should get confirmation that IG has
   //! received the last frame where this Publisher wrote data during publish().
   //!
   //!   Set true when this publisher writes information that does not change often
   //!   but should be delivered reliably. Publisher will be marked as dirty to
   //!   force re-sending data if the frame containing the last write is not confimed
   //!   to have been received by the IG.
   virtual void setNeedsReceiptConfirmation(bool needs);
   virtual bool needsReceiptConfirmation() const;
 
   //! @brief Called when the IG reports receiving the last frame in which this Pulisher
   //! wrote data during publish().
   //!
   //!   This function is only called if needsReceiptConfirmation() is true.
   virtual void receiptConfirmed() {}
 
   //! @brief Returns the time that last update was sent during publish().
   //! (as cgf->simulationServices()->elapsedRealTime())
   virtual double lastSent();
 
   //! @brief Explictly mark this publisher as dirty so that the data is guaranteed to be
   //! written during the next publish() call.
   virtual void markDirty(bool childrenToo = false);
 
   //! @brief Clear the dirty flag.
   //!
   //!   Note that this does not suppress the normal update mechanism. If the data has
   //!   changed since the last publish() call, then this Publisher will again be
   //!   marked as dirty the next time the publish() invokes updateCigi().
   virtual void markClean(bool childrenToo = false);
 
protected:
   //! @brief Key to uniquely idenfity the shared data instance associated with the
   //! Sim object represented by this Publisher.
   //!
   //!   No shared data will be created if sharedKey returns an empty string, which
   //!   is the default behavior if not overridden by the derived Publisher class.
   //!   Derived Publishers should override this function and return a suitable key
   //!   if they will be using shared data.
   virtual std::string sharedKey() { return ""; }
 
   virtual void setupShared();
   virtual bool verifySharedType() = 0;
 
   //! @brief Derived Publisher classes should override initShared() to set inital
   //! values in the shared CIGI data object.
   virtual void initShared() {}
 
   //! @brief Derived Publisher classes should override initCigi() to set initial
   //! values in the CIGI data.
   virtual void initCigi() {}
 
   //! @brief Derived Publisher classes should override updateShared() to update values
   //! in the shared CIGI data object.
   //!
   //!   updateShared() is called only by the first Publisher for each shared data instance
   //!   to publish() during each Host frame.
   virtual void updateShared() {}
 
   //! @brief Derived Publisher classes should override updateCigi() to update values
   //! in the CIGI data.
   //!
   //!   If shared data is used, the expected pattern is to copy values from shared data
   //!   into CIGI data at this point. updateShared() is called, if necessary, before
   //!   updateCigi() so that shared data contains the most recent object state.
   //!
   //!   updateCigi() is called during publish(), before write(). updateCigi() is expected
   //!   to set the dirty flag true if there are changes to the CIGI data. write() will be
   //!   called only if this Publisher is marked dirty.
   virtual void updateCigi() {}
 
   //! Internal class function invoked from publish if state is dirty. Packs CIGI data
   //! into CigiOutgoingMsg.
   virtual void write(CigiOutgoingMsg& out);
 
   //! @brief Derived Publisher classes should override createChildre() to create
   //! child Publishers, if necessary.
   //!
   //!   createChildren() is called during init().
   virtual void createChildren() {}
 
   virtual void tickChildren(double dt);
   virtual void publishChildren(CigiOutgoingMsg& out);
 
protected:
   CigiBasePtr mySharedData;
 
   bool myEnabled;
   bool myNeedsConfirmation;
   double myLastSentToIg;
};
 
#define UPDATE_FROM_SHARED(type, value) updateValue<type>(&cigi()->value, shared()->value)
 
} // namespace makVre