waterSurfaceStateComponent.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>




namespace makVrf
{

   struct DT_DLL_vrfStateData DtWaterSurfaceStateComponentData
   {
      DtWaterSurfaceStateComponentData() 
         : myWaterCurrentSpeed(0.)
         , myWaterCurrentDirection(0.)
         , myTidalOffset(0.)
         , mySwellState(0)
         , mySwellStateDirection(0.)
         , mySeaState(0)
         , mySeaStateDirection(0.)
         , mySurfaceTransparency(0.)
         , myWindDrivenSeaStateEnabled(false)
         , myChoppiness(0.)
         , mySurgeDepth(0.)
         , myDepthOffset(0.)
         , myWindFetch(0.)
         , myPriority(0)
      {};

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

      DtWaterSurfaceStateComponentData& operator=(const DtWaterSurfaceStateComponentData& orig)
      {
         {
            myWaterCurrentSpeed = orig.myWaterCurrentSpeed;
            myWaterCurrentDirection = orig.myWaterCurrentDirection;
            myTidalOffset = orig.myTidalOffset;
            mySwellState = orig.mySwellState;
            mySwellStateDirection = orig.mySwellStateDirection;
            mySeaState = orig.mySeaState;
            mySeaStateDirection = orig.mySeaStateDirection;
            mySurfaceTransparency = orig.mySurfaceTransparency;
            myWindDrivenSeaStateEnabled = orig.myWindDrivenSeaStateEnabled;
            myChoppiness = orig.myChoppiness;
            mySurgeDepth = orig.mySurgeDepth;
            myDepthOffset = orig.myDepthOffset;
            myWindFetch = orig.myWindFetch;
            myPriority = orig.myPriority;
         }
         return *this;
      };
      ACCESSOR_MUTATOR_MEMBER(double, waterCurrentSpeed, WaterCurrentSpeed);
      ACCESSOR_MUTATOR_MEMBER(double, waterCurrentDirection, WaterCurrentDirection);
      ACCESSOR_MUTATOR_MEMBER(double, tidalOffset, TidalOffset);
      ACCESSOR_MUTATOR_MEMBER(int, swellState, SwellState);
      ACCESSOR_MUTATOR_MEMBER(double, swellStateDirection, SwellStateDirection);
      ACCESSOR_MUTATOR_MEMBER(int, seaState, SeaState);
      ACCESSOR_MUTATOR_MEMBER(double, seaStateDirection, SeaStateDirection);
      ACCESSOR_MUTATOR_MEMBER(double, surfaceTransparency, SurfaceTransparency);
      ACCESSOR_MUTATOR_MEMBER(bool, windDrivenSeaStateEnabled, WindDrivenSeaStateEnabled);
      ACCESSOR_MUTATOR_MEMBER(double, choppiness, Choppiness);
      ACCESSOR_MUTATOR_MEMBER(double, surgeDepth, SurgeDepth);
      ACCESSOR_MUTATOR_MEMBER(double, depthOffset, DepthOffset);
      ACCESSOR_MUTATOR_MEMBER(double, windFetch, WindFetch);
      ACCESSOR_MUTATOR_MEMBER(int, priority, Priority);
   };

   class DT_DLL_vrfStateData DtWaterSurfaceStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::WaterSurfaceStateComponent)

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

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, waterCurrentSpeed, WaterCurrentSpeed);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, waterCurrentDirection, WaterCurrentDirection);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, tidalOffset, TidalOffset);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, swellState, SwellState);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, swellStateDirection, SwellStateDirection);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, seaState, SeaState);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, seaStateDirection, SeaStateDirection);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, surfaceTransparency, SurfaceTransparency);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, windDrivenSeaStateEnabled, WindDrivenSeaStateEnabled);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, choppiness, Choppiness);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, surgeDepth, SurgeDepth);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, depthOffset, DepthOffset);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, windFetch, WindFetch);
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, priority, Priority);

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

   protected:
      bool myIsRemoteComponent = false;
   };

   class DT_DLL_vrfStateData DtWaterSurfaceStateComponentNextFrame : public DtStateComponentNextFrameTemplate< DtWaterSurfaceStateComponent, DtWaterSurfaceStateComponentData >
   {
   public:
      DtWaterSurfaceStateComponentNextFrame(DtStateData* sd)
         : DtStateComponentNextFrameTemplate(sd)
      {

      };
      virtual ~DtWaterSurfaceStateComponentNextFrame() override {};
     
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, waterCurrentSpeed, WaterCurrentSpeed);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, waterCurrentDirection, WaterCurrentDirection);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, tidalOffset, TidalOffset);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(int, swellState, SwellState);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, swellStateDirection, SwellStateDirection);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(int, seaState, SeaState);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, seaStateDirection, SeaStateDirection);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, surfaceTransparency, SurfaceTransparency);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(bool, windDrivenSeaStateEnabled, WindDrivenSeaStateEnabled);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, choppiness, Choppiness);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, surgeDepth, SurgeDepth);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, depthOffset, DepthOffset);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(double, windFetch, WindFetch);
      NEXTFRAME_ACCESSOR_MUTATOR_WITHLOCK(int, priority, Priority);

   protected:
      mutable tbb::spin_rw_mutex myMutex;
   };

   class DT_DLL_vrfStateData DtWaterSurfaceStateComponentCurrentFrame : public DtStateComponentCurrentFrameTemplate< DtWaterSurfaceStateComponent, DtWaterSurfaceStateComponentNextFrame, DtWaterSurfaceStateComponentData>
   {
   public:
      DtWaterSurfaceStateComponentCurrentFrame(DtStateData* sd)
         : DtStateComponentCurrentFrameTemplate(sd)
      {
      };

      CURRENTFRAME_ACCESSOR(double, waterCurrentSpeed, WaterCurrentSpeed);
      CURRENTFRAME_ACCESSOR(double, waterCurrentDirection, WaterCurrentDirection);
      CURRENTFRAME_ACCESSOR(double, tidalOffset, TidalOffset);
      CURRENTFRAME_ACCESSOR(int, swellState, SwellState);
      CURRENTFRAME_ACCESSOR(double, swellStateDirection, SwellStateDirection);
      CURRENTFRAME_ACCESSOR(int, seaState, SeaState);
      CURRENTFRAME_ACCESSOR(double, seaStateDirection, SeaStateDirection);
      CURRENTFRAME_ACCESSOR(double, surfaceTransparency, SurfaceTransparency);
      CURRENTFRAME_ACCESSOR(bool, windDrivenSeaStateEnabled, WindDrivenSeaStateEnabled);
      CURRENTFRAME_ACCESSOR(double, choppiness, Choppiness);
      CURRENTFRAME_ACCESSOR(double, surgeDepth, SurgeDepth);
      CURRENTFRAME_ACCESSOR(double, depthOffset, DepthOffset);
      CURRENTFRAME_ACCESSOR(double, windFetch, WindFetch);
      CURRENTFRAME_ACCESSOR(int, priority, Priority);
   };

   using DtWaterSurfaceStateComponentImplementation = DtStateComponentImplementationTemplate<DtWaterSurfaceStateComponent, DtWaterSurfaceStateComponentCurrentFrame, DtWaterSurfaceStateComponentNextFrame>;

   typedef DtStateComponentCreator<DtWaterSurfaceStateComponentImplementation> DtWaterSurfaceStateComponentCreator;

}