subsurfaceStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/stateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include <vrfExtObjects/vrfWeatherStateEnums.h>
#include <vrfStateData/stateComponentImplementationTemplate.h>
#include <vrfutil/rwWindLevels.h>
#include <tbb/spin_rw_mutex.h>

namespace makVrf
{

   struct DtVrfSubsurfaceLayer
   {
      DtVrfSubsurfaceLayer()
         : myDepth(0.)
         , myPermeability(0.)
         , myThickness(0.)
         , myPriority(0)
      {

      };
      DtVrfSubsurfaceLayer(double depth, double thickness, double permeability, int priority)
         : myDepth(depth)
         , myThickness(thickness)
         , myPermeability(permeability)
         , myPriority(priority)
      {

      };
      DtVrfSubsurfaceLayer(const DtVrfSubsurfaceLayer& orig)
      {
         *this = orig;
      };

      DtVrfSubsurfaceLayer& operator=(const DtVrfSubsurfaceLayer& orig)
      {
         {
            myDepth = orig.myDepth;
            myPermeability = orig.myPermeability;
            myPriority = orig.myPriority;
            myThickness = orig.myThickness;
         }
         return *this;
      };

      bool operator<(const DtVrfSubsurfaceLayer& other) const
      {
         return myDepth < other.myDepth;
      };

      bool operator==(const DtVrfSubsurfaceLayer& other) const
      {
         return (myDepth == other.myDepth
            && myPriority == other.myPriority
            && myThickness == other.myThickness
            && myPermeability == other.myPermeability);
      };
      bool operator!=(const DtVrfSubsurfaceLayer& other) const
      {
         return !(*this == other);
      };
      ACCESSOR_MUTATOR_MEMBER(double, depth, Depth);
      ACCESSOR_MUTATOR_MEMBER(double, thickness, Thickness);
      ACCESSOR_MUTATOR_MEMBER(double, permeability, Permeability);
      ACCESSOR_MUTATOR_MEMBER(int, priority, Priority);
   };

   typedef std::multiset<DtVrfSubsurfaceLayer> DtVrfSubsurfaceLayerSet;


   struct DT_DLL_vrfStateData DtSubsurfaceStateComponentData
   {
      DtSubsurfaceStateComponentData()
         : myUnderwaterVisibility(0.)
         , mySubsurfaceLayers()
         , myAmbientWaterTemperature(0.)
         , myPriority(0)
      {};

      DtSubsurfaceStateComponentData(const DtSubsurfaceStateComponentData& orig)
      {
         *this = orig;
      };

      DtSubsurfaceStateComponentData& operator=(const DtSubsurfaceStateComponentData& orig)
      {
         {
            myUnderwaterVisibility = orig.myUnderwaterVisibility;
            mySubsurfaceLayers = orig.mySubsurfaceLayers;
            myAmbientWaterTemperature = orig.myAmbientWaterTemperature;
            myPriority = orig.myPriority;
         }
         return *this;
      };

      ACCESSOR_MUTATOR_MEMBER(double, underwaterVisibility, UnderwaterVisibility);
      ACCESSOR_MUTATOR_MEMBER(DtVrfSubsurfaceLayerSet, subsurfaceLayers, SubsurfaceLayers);
      ACCESSOR_MUTATOR_MEMBER(double, ambientWaterTemperature, AmbientWaterTemperature);
      ACCESSOR_MUTATOR_MEMBER(unsigned int, priority, Priority);
   };

   class DT_DLL_vrfStateData DtSubsurfaceStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::SubsurfaceStateComponent)

         DtSubsurfaceStateComponent(DtStateData* storage)
         : DtFrameStateInterface(storage)
      {
      }

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, underwaterVisibility, UnderwaterVisibility);
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtVrfSubsurfaceLayerSet, subsurfaceLayers, SubsurfaceLayers);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer1Depth, ThermoclineLayer1Depth);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer1Thickness, ThermoclineLayer1Thickness);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer1Permeability, ThermoclineLayer1Permeability);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer2Depth, ThermoclineLayer2Depth);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer2Thickness, ThermoclineLayer2Thickness);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer2Permeability, ThermoclineLayer2Permeability);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer3Depth, ThermoclineLayer3Depth);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer3Thickness, ThermoclineLayer3Thickness);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer3Permeability, ThermoclineLayer3Permeability);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer4Depth, ThermoclineLayer4Depth);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer4Thickness, ThermoclineLayer4Thickness);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer4Permeability, ThermoclineLayer4Permeability);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer5Depth, ThermoclineLayer5Depth);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer5Thickness, ThermoclineLayer5Thickness);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, thermoclineLayer5Permeability, ThermoclineLayer5Permeability);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, ambientWaterTemperature, AmbientWaterTemperature);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, priority, Priority);

      virtual void addSubsurfaceLayer(const DtVrfSubsurfaceLayer& layerToAdd) { throw DtUnimplementedMethod("addSubsurfaceLayer is not implemented by this class."); };
      virtual void removeSubsurfaceLayer(const DtVrfSubsurfaceLayer& layerToRemove) { throw DtUnimplementedMethod("removeSubsurfaceLayer is not implemented by this class."); };

      void setIsRemoteComponent(bool b) { myIsRemoteComponent = b; };

   protected:
      bool myIsRemoteComponent = false;
   };

#define THERMOCLINE_GETTER(number, Accessor, Setter) \
   const double thermoclineLayer##number####Setter() const override \
   { \
      const unsigned indexToUse = number - 1; \
      DtVrfSubsurfaceLayer dummy; \
      thermoclineLayer(indexToUse, dummy); \
      return dummy.Accessor(); \
   }; 

#define THERMOCLINE_SETTER(number, Accessor, Setter) \
   void setThermoclineLayer##number####Setter( const double& Accessor ) override \
   { \
      const unsigned indexToUse = number - 1; \
      DtVrfSubsurfaceLayer dummy; \
      thermoclineLayer(indexToUse, dummy); \
      if (dummy.Accessor() != Accessor) \
      { \
         dummy.set##Setter(Accessor); \
         markModified(); \
         setThermoclineLayerByIndex(dummy, indexToUse); \
      } \
   };

#define THERMOCLINE_SETTER_GETTER(number, Accessor, Setter) \
   THERMOCLINE_GETTER(number, Accessor, Setter); \
   THERMOCLINE_SETTER(number, Accessor, Setter);



#define NEXTFRAME_ACCESSOR_MUTATOR_(MemberType, Accessor, MutatorAndMember) \
   public: \
      const MemberType Accessor() const override { return frameState().Accessor(); }; \
      void set##MutatorAndMember(const MemberType& v) override { if (frameState().Accessor() != v) { markModified(); frameState().set##MutatorAndMember(v); } };

   class DT_DLL_vrfStateData DtSubsurfaceStateComponentNextFrame : public DtStateComponentNextFrameTemplate< DtSubsurfaceStateComponent, DtSubsurfaceStateComponentData >
   {
   public:
      DtSubsurfaceStateComponentNextFrame(DtStateData* sd)
         : DtStateComponentNextFrameTemplate(sd)
      {

      };
      virtual ~DtSubsurfaceStateComponentNextFrame() override {};

      NEXTFRAME_ACCESSOR_MUTATOR(double, underwaterVisibility, UnderwaterVisibility);
      NEXTFRAME_ACCESSOR_BY_REF_MUTATOR(DtVrfSubsurfaceLayerSet, subsurfaceLayers, SubsurfaceLayers);
      NEXTFRAME_ACCESSOR_MUTATOR(double, ambientWaterTemperature, AmbientWaterTemperature);
      NEXTFRAME_ACCESSOR_MUTATOR(int, priority, Priority);

      THERMOCLINE_SETTER_GETTER(1, depth, Depth);
      THERMOCLINE_SETTER_GETTER(1, thickness, Thickness);
      THERMOCLINE_SETTER_GETTER(1, permeability, Permeability);

      THERMOCLINE_SETTER_GETTER(2, depth, Depth);
      THERMOCLINE_SETTER_GETTER(2, thickness, Thickness);
      THERMOCLINE_SETTER_GETTER(2, permeability, Permeability);

      THERMOCLINE_SETTER_GETTER(3, depth, Depth);
      THERMOCLINE_SETTER_GETTER(3, thickness, Thickness);
      THERMOCLINE_SETTER_GETTER(3, permeability, Permeability);

      THERMOCLINE_SETTER_GETTER(4, depth, Depth);
      THERMOCLINE_SETTER_GETTER(4, thickness, Thickness);
      THERMOCLINE_SETTER_GETTER(4, permeability, Permeability);

      THERMOCLINE_SETTER_GETTER(5, depth, Depth);
      THERMOCLINE_SETTER_GETTER(5, thickness, Thickness);
      THERMOCLINE_SETTER_GETTER(5, permeability, Permeability);

      virtual void addSubsurfaceLayer(const DtVrfSubsurfaceLayer& layerToAdd) override;
      virtual void removeSubsurfaceLayer(const DtVrfSubsurfaceLayer& layerToAdd) override;
   protected:
      bool thermoclineLayer(unsigned int index, DtVrfSubsurfaceLayer& layer) const;
      bool removeThermoclineLayer(unsigned int index, DtVrfSubsurfaceLayer& layer);
      void setThermoclineLayerByIndex(DtVrfSubsurfaceLayer layer, unsigned int index);

   protected:
      mutable tbb::spin_rw_mutex myMutex;
   };

   class DT_DLL_vrfStateData DtSubsurfaceStateComponentCurrentFrame : public DtStateComponentCurrentFrameTemplate< DtSubsurfaceStateComponent, DtSubsurfaceStateComponentNextFrame, DtSubsurfaceStateComponentData>
   {
   public:
      DtSubsurfaceStateComponentCurrentFrame(DtStateData* sd)
         : DtStateComponentCurrentFrameTemplate(sd)
      {
      };

      CURRENTFRAME_ACCESSOR(double, underwaterVisibility, UnderwaterVisibility);
      CURRENTFRAME_ACCESSOR_BY_REF(DtVrfSubsurfaceLayerSet, subsurfaceLayers, SubsurfaceLayers);
      CURRENTFRAME_ACCESSOR(double, ambientWaterTemperature, AmbientWaterTemperature);
      CURRENTFRAME_ACCESSOR(int, priority, Priority);



      THERMOCLINE_GETTER(1, depth, Depth);
      THERMOCLINE_GETTER(1, thickness, Thickness);
      THERMOCLINE_GETTER(1, permeability, Permeability);

      THERMOCLINE_GETTER(2, depth, Depth);
      THERMOCLINE_GETTER(2, thickness, Thickness);
      THERMOCLINE_GETTER(2, permeability, Permeability);

      THERMOCLINE_GETTER(3, depth, Depth);
      THERMOCLINE_GETTER(3, thickness, Thickness);
      THERMOCLINE_GETTER(3, permeability, Permeability);

      THERMOCLINE_GETTER(4, depth, Depth);
      THERMOCLINE_GETTER(4, thickness, Thickness);
      THERMOCLINE_GETTER(4, permeability, Permeability);

      THERMOCLINE_GETTER(5, depth, Depth);
      THERMOCLINE_GETTER(5, thickness, Thickness);
      THERMOCLINE_GETTER(5, permeability, Permeability);

   protected:
      bool thermoclineLayer(unsigned int index, DtVrfSubsurfaceLayer& layer) const;
   };

   using DtSubsurfaceStateComponentImplementation = DtStateComponentImplementationTemplate<DtSubsurfaceStateComponent, DtSubsurfaceStateComponentCurrentFrame, DtSubsurfaceStateComponentNextFrame>;

   typedef DtStateComponentCreator<DtSubsurfaceStateComponentImplementation> DtSubsurfaceStateComponentCreator;

}