globalEnvironmentStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/stateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include <vlpi/netStructs.h>
#include <vlutil/vlString.h>
#include <vrfExtObjects/vrfCloudLayerStateEnums.h>
#include "legionDataStore/writeStateInstance.h"
#include "legionDataStore/readStateInstance.h"
#include "vrfOM/sets/writeSimulationDateTimeRepository.hpp"
#include "vrfOM/sets/readSimulationDateTimeRepository.hpp"

namespace makVrf
{
   struct DT_DLL_vrfStateData DtGlobalEnvironmentStateComponentData
   {
      DtGlobalEnvironmentStateComponentData()
      {
         myScenarioStartTimeAtLocalOnFirstObjectCreationToTime = 36000;
         myUpdateWhenTimeChangedBy = 60.;
         myDateAndTimeOfDay = 43200.0;
         myScenarioStartTimeIsLocal = true;
      }

      DtGlobalEnvironmentStateComponentData(const DtGlobalEnvironmentStateComponentData& orig)
      {
         myScenarioStartTimeAtLocalOnFirstObjectCreationToTime = orig.myScenarioStartTimeAtLocalOnFirstObjectCreationToTime;
         myUpdateWhenTimeChangedBy = orig.myUpdateWhenTimeChangedBy;
         myDateAndTimeOfDay = orig.myDateAndTimeOfDay;
         myScenarioStartTimeIsLocal = orig.myScenarioStartTimeIsLocal;
      }

      DtGlobalEnvironmentStateComponentData& operator=(const DtGlobalEnvironmentStateComponentData& rhs)
      {
         myScenarioStartTimeAtLocalOnFirstObjectCreationToTime = rhs.myScenarioStartTimeAtLocalOnFirstObjectCreationToTime;
         myUpdateWhenTimeChangedBy = rhs.myUpdateWhenTimeChangedBy;
         myDateAndTimeOfDay = rhs.myDateAndTimeOfDay;
         myScenarioStartTimeIsLocal = rhs.myScenarioStartTimeIsLocal;
         return *this;
      }

      bool dateAndTimeOfDayHasBeenSet() const
      {
         return (myDateAndTimeOfDay != 43200.0);
      }

      DEFINE_ACCESSOR_MUTATOR(double, updateWhenTimeChangedBy, UpdateWhenTimeChangedBy)
      DEFINE_ACCESSOR_MUTATOR(double, dateAndTimeOfDay, DateAndTimeOfDay)
      DEFINE_ACCESSOR_MUTATOR(int, scenarioStartTimeAtLocalOnFirstObjectCreationToTime, ScenarioStartTimeAtLocalOnFirstObjectCreationToTime)
      DEFINE_ACCESSOR_MUTATOR(bool, scenarioStartTimeIsLocal, ScenarioStartTimeIsLocal)

   protected:
      int myScenarioStartTimeAtLocalOnFirstObjectCreationToTime;
      double myUpdateWhenTimeChangedBy;
      double myDateAndTimeOfDay;

      bool myScenarioStartTimeIsLocal;
   };

   class DT_DLL_vrfStateData DtGlobalEnvironmentStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::GlobalEnvironmentStateComponent)

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

      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, updateWhenTimeChangedBy, UpdateWhenTimeChangedBy)
      UNDEFINED_RETURNVALUE_ACCESSOR(double, dateAndTimeOfDay)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, timeOfDayAdvancementSpeed, TimeOfDayAdvancementSpeed)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, useDayNightIlluminationModel, UseDayNightIlluminationModel)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(int, scenarioStartTimeAtLocalOnFirstObjectCreationToTime, ScenarioStartTimeAtLocalOnFirstObjectCreationToTime)
      virtual void setDateAndTimeOfDay(const double&, bool markModified = false) { throw DtUnimplementedMethod("void setDateAndTimeOfDay(double, bool markModified = false) is not implemented for this class."); };

      UNDEFINED_RETURNVALUE_ACCESSOR(DtString, timeOfDayString)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, userModifiedTime, UserModifiedTime)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, timeToLocalOnFirstPlacement, TimeToLocalOnFirstPlacement)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, alreadySetTimePlacement, AlreadySetTimePlacement)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, canSetScenarioPreStartTime, CanSetScenarioPreStartTime)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, scenarioStartTimeIsLocal, ScenarioStartTimeIsLocal)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, timeOfDay, TimeOfDay)
   };

   class DT_DLL_vrfStateData DtGlobalEnvironmentStateComponentNextFrame : public DtGlobalEnvironmentStateComponent
   {
   public:
      DtGlobalEnvironmentStateComponentNextFrame(DtStateData*);

      const DtGlobalEnvironmentStateComponentData& frameState() const { return myData; };
      DtGlobalEnvironmentStateComponentData& frameState() { return myData; };

      const double dateAndTimeOfDay() const;
      void setDateAndTimeOfDay(const double&, bool markModified = false);

      const double updateWhenTimeChangedBy() const;
      void setUpdateWhenTimeChangedBy(const double&);

      const double timeOfDayAdvancementSpeed() const;
      void setTimeOfDayAdvancementSpeed(const double&);

      const bool useDayNightIlluminationModel() const;
      void setUseDayNightIlluminationModel(const bool&);

      const int scenarioStartTimeAtLocalOnFirstObjectCreationToTime() const;
      void setScenarioStartTimeAtLocalOnFirstObjectCreationToTime(const int&);

      void setTimeToLocalOnFirstPlacement(const bool&);
      const bool timeToLocalOnFirstPlacement() const;

      void setUserModifiedTime(const bool&);
      const bool userModifiedTime() const;

      void setAlreadySetTimePlacement(const bool&);
      const bool alreadySetTimePlacement() const;

      void setCanSetScenarioPreStartTime(const bool&);
      const bool canSetScenarioPreStartTime() const;

      void setScenarioStartTimeIsLocal(const bool&);
      const bool scenarioStartTimeIsLocal() const;

      const DtString timeOfDayString() const;
      void setTimeOfDay(const double& value);

      const double timeOfDay() const;

      virtual void makeWritable();

      virtual void makeReadOnly();

   protected:
      VRF::WriteSimulationDateTimeRepository myWriteSimulationDateTimeRepository;
      DtStateData* myStateData;
      DtGlobalEnvironmentStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtGlobalEnvironmentStateComponentCurrentFrame : public DtGlobalEnvironmentStateComponent
   {
   public:
      DtGlobalEnvironmentStateComponentCurrentFrame(DtStateData*);
      virtual ~DtGlobalEnvironmentStateComponentCurrentFrame();

      const DtGlobalEnvironmentStateComponentData& frameState() const { return myData; };

      bool readComponentValid() const;
      bool findReadComponent();

      const double updateWhenTimeChangedBy() const;
      const double dateAndTimeOfDay() const;
      const double timeOfDayAdvancementSpeed() const;
      const bool useDayNightIlluminationModel() const;
      const int scenarioStartTimeAtLocalOnFirstObjectCreationToTime() const;
      const DtString timeOfDayString() const;
      const bool timeToLocalOnFirstPlacement() const;
      const bool userModifiedTime() const;
      const bool scenarioStartTimeIsLocal() const;

      const bool alreadySetTimePlacement() const;

      const bool canSetScenarioPreStartTime() const;
      const double timeOfDay() const;

   protected:
      void dateAndTimeOfDayChanged();

      friend class DtGlobalEnvironmentStateComponentImplementation;
      void advanceFrame(const DtGlobalEnvironmentStateComponentData& data)
      {
         myData = data;
      }

   protected:
      VRF::ReadSimulationDateTimeRepository myReadSimulationDateTimeRepository;
      unsigned int myCallbackHandle;
      DtStateData* myStateData;
      DtGlobalEnvironmentStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtGlobalEnvironmentStateComponentImplementation : public DtDoubleBufferedStateComponent<DtGlobalEnvironmentStateComponent>
   {
   public:
      DtGlobalEnvironmentStateComponentImplementation(DtStateData*);

      bool isDoubleBuffered() { return true; };
      const DtFrameStateInterface* currentFrameState() const { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const { return &myNextFrameState; };

      void updateDataStorage();

      void updateStateData(DtStateData* sd)
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      virtual bool forceAdvance();

      virtual void firstFrameAdvance() override;

      virtual void initializeFromParameters(const DtVrfObjectParameters*);

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtGlobalEnvironmentStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

   protected:
      DtGlobalEnvironmentStateComponentCurrentFrame myCurrentFrameState;
      DtGlobalEnvironmentStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;
   };

   typedef DtStateComponentCreator<DtGlobalEnvironmentStateComponentImplementation> DtGlobalEnvironmentStateComponentCreator;
}