DtObserverModeRecord.h

Go to the documentation of this file.

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


#pragma once

#include <makArchives/makArchives.h>

#include <string>
#include <map>
#include <bitset>

namespace makArchives
{
   class DT_DLL_MAKARCHIVES DtObserverModeRecord
   {
   public:
      enum class DtLodCenterDistanceToUseFunction : int
      {
         MinDistance,
         MaxDistance
      };

   public:
   
      typedef std::map< std::string, bool> ObserverSettingsMap;

      DtObserverModeRecord();
      
      DtObserverModeRecord( const DtObserverModeRecord& orig );
      
      ~DtObserverModeRecord();  
      
      DtObserverModeRecord& operator=( const DtObserverModeRecord& orig );

      void setModeKey( const std::string& modeKey );
      
      const std::string& modeKey() const;
     
      void setName( const std::string& name );
      
      const std::string& name() const;
    
      void setIs2D( bool trueOrFalse );  
      
      bool is2D() const;
      
      void setModelSet( int modelSet );
      
      int modelSet() const;

      void setKeyMap( const std::string& keyMap );
      
      const std::string& keyMap() const;

      const std::string& sensor() const;
      void setSensor(const std::string& sensor);
      
      int gainPrecision() const;
      void setGainPrecision( int amt );
      
      int orbitSpeedGain() const;
      void setOrbitSpeedGain( int gain );
      
      int linearScaledSpeedGain() const;
      void setLinearScaledSpeedGain( int gain );
       
      int linearUnscaledSpeedGain() const;
      void setLinearUnscaledSpeedGain( int gain );
          
      int rotationSpeedGain() const;
      void setRotationSpeedGain( int gain );
          
      double modelScaleFactor() const;
      void setModelScaleFactor( double modelScaleFactor );
          
      const std::string& modelScaleType() const;
      void setModelScaleType( const std::string& modelScaleType );

      double maxModelScaleFactor() const;
      void setMaxModelScaleFactor( double maxModelScaleFactor );

      void setObserverSetting( const std::string& key, bool enabled );
      bool observerSetting( const std::string& key ) const;

      void setSpeedScalingMode( unsigned int mode );
      unsigned int speedScalingMode() const;

      void setSpeedScalingMslModeOffset( double offset );
      double speedScalingMslModeOffset() const;

      void setCameraShakeEnabled( bool enabled );
      bool cameraShakeEnabled() const;

      void setCameraShakeIntensity( double offset );
      double cameraShakeIntensity() const;

      void setLodScaleCenterEnabled(bool enabled);
      bool lodScaleCenterEnabled() const;

      void setLodScaleCenterMagMinLimit(double limit);
      double lodScaleCenterMagMinLimit() const;

      void setIsCameraLocationIncluded(bool includeCameraLocation);
      double isCameraLocationIncluded() const;

      void setIncludedFocusPoints(std::bitset<7> includedFocusPoints);
      std::bitset<7> includedFocusPoints() const;

      void setLodCenterDistanceToUse(DtLodCenterDistanceToUseFunction limit);
      DtLodCenterDistanceToUseFunction lodCenterDistanceToUse() const;

      void setIsScaledCameraDistanceUsed(double limit);
      double isScaledCameraDistanceUsed() const;

      void setLodCenterMinimumAngleFromViewVector(double minAngle);
      double lodCenterMinimumAngleFromViewVector() const;

      unsigned int northType() const;
      void setNorthType(unsigned int northType);

      void setColorControlEnabled(bool enabled);
      bool colorControlEnabled() const;

      void setColorControlInvert(bool enabled);
      bool colorControlInvert() const;

      void setColorControlContrast(double value);
      double colorControlContrast() const;

      void setColorControlBrightness(double value);
      double colorControlBrightness() const;

      void setColorControlColorMix(double value);
      double colorControlColorMix() const;

      const ObserverSettingsMap& observerSettingsMap() const;
  
       
   protected:
      friend class boost::serialization::access;
      
      template <typename Archive>
      void serialize(Archive& ar, unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myModeKey);
         ar & BOOST_SERIALIZATION_NVP(myName);
         ar & BOOST_SERIALIZATION_NVP(myIs2D);
         ar & BOOST_SERIALIZATION_NVP(myModelSet);
         ar & BOOST_SERIALIZATION_NVP(myKeyMap);
         ar & BOOST_SERIALIZATION_NVP(myOrbitSpeedGain);
         ar & BOOST_SERIALIZATION_NVP(myLinearScaledSpeedGain);
         ar & BOOST_SERIALIZATION_NVP(myLinearUnscaledSpeedGain);
         ar & BOOST_SERIALIZATION_NVP(myRotationSpeedGain);
         ar & BOOST_SERIALIZATION_NVP(myGainPrecision);
         if ( version >= 1 )
         {
            ar & BOOST_SERIALIZATION_NVP(myModelScaleFactor);
         }
         if ( version >= 2 )
         {
            if ( version < 6 )
            {
               ar & BOOST_SERIALIZATION_NVP(myModelScaleType);
            }
            ar & BOOST_SERIALIZATION_NVP(myMaxModelScaleFactor);
         }
         if ( version >= 3 )
         {
            ar & BOOST_SERIALIZATION_NVP(mySensor);
         }
         ar & BOOST_SERIALIZATION_NVP(myObserverSettingsMap);
         if ( version >= 4 )
         {
            ar & BOOST_SERIALIZATION_NVP(mySpeedScalingMode);
            ar & BOOST_SERIALIZATION_NVP(mySpeedScalingMslModeOffset);
         }
         if ( version >= 5 )
         {
            ar & BOOST_SERIALIZATION_NVP(myCameraShakeEnabled);
            ar & BOOST_SERIALIZATION_NVP(myCameraShakeIntensity);
         }
         if ( version >= 6 )
         {
            ar & BOOST_SERIALIZATION_NVP(myMutableModelScaleTypeString);
         }
         if (version >= 7)
         {
            ar & BOOST_SERIALIZATION_NVP(myLodScaleCenterEnabled);
            ar & BOOST_SERIALIZATION_NVP(myLodScaleCenterMagMinLimit);
         }
         if (version >= 8)
         {
            ar & BOOST_SERIALIZATION_NVP(myNorthType);
         }
         if (version >= 9)
         {
            ar& BOOST_SERIALIZATION_NVP(myColorControlEnabled);
            ar& BOOST_SERIALIZATION_NVP(myColorControlInvert);
            ar& BOOST_SERIALIZATION_NVP(myColorControlContrast);
            ar& BOOST_SERIALIZATION_NVP(myColorControlBrightness);
            ar& BOOST_SERIALIZATION_NVP(myColorControlColorMix);
         }
         if (version >= 10)
         {
            ar & BOOST_SERIALIZATION_NVP(myLodCenterIsCameraLocationUsed);
            ar & BOOST_SERIALIZATION_NVP(myLodCenterIncludedFocusPoints);
            ar & BOOST_SERIALIZATION_NVP(myLodCenterDistanceToUseFunction);
            ar & BOOST_SERIALIZATION_NVP(myLodCenterIsScaledCameraDistanceUsed);
            ar & BOOST_SERIALIZATION_NVP(myLodCenterMinimumAngleFromViewVector);
         }
      }
      
   protected:
      std::string myModeKey;
      std::string myName;
      std::string mySensor;
      bool myIs2D;
      std::string myKeyMap;
      int myModelSet;
      int myOrbitSpeedGain;
      int myLinearScaledSpeedGain;
      int myLinearUnscaledSpeedGain;
      int myRotationSpeedGain;
      int myGainPrecision;
      double myModelScaleFactor;
      ObserverSettingsMap myObserverSettingsMap;
      unsigned myModelScaleType;
      double myMaxModelScaleFactor;
      unsigned mySpeedScalingMode;
      double mySpeedScalingMslModeOffset;
      bool myCameraShakeEnabled;
      double myCameraShakeIntensity;
      bool myLodScaleCenterEnabled;
      double myLodScaleCenterMagMinLimit;
      unsigned int myNorthType;
      bool myColorControlEnabled;
      bool myColorControlInvert;
      float myColorControlContrast;
      float myColorControlBrightness;
      float myColorControlColorMix;

      bool myLodCenterIsCameraLocationUsed;
      std::string myLodCenterIncludedFocusPoints;
      std::string myLodCenterDistanceToUseFunction;
      bool myLodCenterIsScaledCameraDistanceUsed;
      double myLodCenterMinimumAngleFromViewVector;

   private:
      // Mutable so that we can provide backward compatibility with settings files that contain
      // the old enum instead of the new string
      mutable std::string myMutableModelScaleTypeString;
   };
}

BOOST_CLASS_VERSION(makArchives::DtObserverModeRecord,10)