disabledEnvironment.h

Go to the documentation of this file.

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



#pragma once

#include <vrvCore/DtCloudLayer.h>
#include <vrvCore/DtEnvironmentInterface.h>

#include <vrvCore/DtDe.h>
#include <vrvCore/DtScene.h>
#include <vrvCore/DtEnvironment.h>

namespace makVrf
{

   class DtDisabledEnvironment : public makVrv::DtEnvironmentInterface
   {
   public:
      DtDisabledEnvironment(makVrv::DtDe& de) : makVrv::DtEnvironmentInterface()
         , myPrecipitationType(makVrv::DtEnvironmentInterface::None)
         , myDe(de)
         , myEnvironmentList(de)
      {

      }
      virtual void clear() {}
      virtual void getRecord(makArchives::DtEnvironmentRecord& record)
      {
         record = myCurrentSettings;
      }

      virtual void setFromRecord(
         const makArchives::DtEnvironmentRecord& record)
      {
         myCurrentSettings = record;
      }

      virtual void saveEnvironment(const std::string& envName) {}
      virtual void removeEnvironment(const std::string& envName) {}
      virtual void renameEnvironment(
         const std::string& oldName, const std::string& newName) {}
      virtual void getEnvironmentNames(std::vector<std::string>& names)
      {
         return myDe.scene().environment().getEnvironmentNames(names);
      }

      virtual void setEnvironment(const std::string& envName)
      {
         try
         {
            setFromRecord(myEnvironmentList.getEnvironment(envName));
         }
         catch(...)
         {
         }
      }

      virtual void setDefaultEnvironmentName(const std::string& name) {}
      virtual std::string defaultEnvironmentName() const { return ""; }
      virtual void setCloudCover(DtVrfWeatherCloudState cloudCover) {}
      virtual DtVrfWeatherCloudState cloudCover() const 
      { return DtVrfWeatherCloudStateClear; }
      virtual int cloudLayerCount() const { return -1.0; }
      virtual const makVrv::DtCloudLayer& cloudLayer(unsigned int layerId) const 
      { return myCloudLayer; }
      virtual void setCloudLayer(
         unsigned int layerId, const makVrv::DtCloudLayer& layer) {}
      virtual void addCloudLayer(const makVrv::DtCloudLayer& layer) {}
      virtual void removeCloudLayer(unsigned int layerId) {}
      virtual void removeCloudLayers() {}
      virtual void setCloudLayerEnabled(unsigned int layerId, bool enabled) {}
      virtual bool useCustomCloudCover() const { return false; }
      virtual void setUseCustomCloudCover(bool enabled) {}
      virtual void setAirTurbidity(float turbidity) {}
      virtual float airTurbidity() const { return -1.0; }
      virtual void setVisibleDistance(float distance) {}
      virtual float visibleDistance() const { return -1.0; }
      virtual void setPrecipitationType(PrecipitationType type)
      {
         myPrecipitationType = type;
      }
      virtual PrecipitationType precipitationType() const 
      {
         return myPrecipitationType;
      }
      virtual void setPrecipitationIntensity(float intensity) {}
      virtual float precipitationIntensity() const { return -1.0; }
      virtual void setWindSpeed(float speed) {}
      virtual float windSpeed() const { return -1.0; }
      virtual void setWindDirection(float direction) {}
      virtual float windDirection() const { return -1.0; }
      virtual void setAmbientAirTemperature(float temperature) {}
      virtual float ambientAirTemperature() const { return -1.0; }
      virtual void setFogHeight(float height) {}
      virtual float fogHeight() const { return -1.0; }
      virtual void setFogColor(const DtVector& color) {}
      virtual DtVector fogColor() const { return DtVector(-1.0, -1.0, -1.0); }
      virtual void setSeaState(int state) {}
      virtual int seaState() const { return -1; }
      virtual void setSeaStateDirection(float dir) {}
      virtual float seaStateDirection() const { return -1.0; }
      virtual void setWindDrivenSeaState(bool enabled) {}
      virtual bool windDrivenSeaState() const { return false; }
      virtual void setSwellState(int state) {}
      virtual int swellState() const { return -1; }
      virtual void setSwellStateDirection(float dir) {}
      virtual float swellStateDirection() const { return -1.0; }
      virtual void setWindFetch(float distance) {}
      virtual float windFetch() const { return -1.0; }
      virtual void setSeaChoppiness(float chop) {}
      virtual float seaChoppiness() const { return -1.0; }
      virtual void setUnderwaterVisibilityEnabled(bool enabled) {}
      virtual bool underwaterVisibilityEnabled() const { return false; }
      virtual void setUnderwaterVisibility(float distance) {}
      virtual float underwaterVisibility() const { return -1.0; }
      virtual void setWaterSurfaceTransparency(float normalizedValue) {}
      virtual float waterSurfaceTransparency() const { return -1.0; }
      virtual void setSurgeDepth(float meters) {}
      virtual float surgeDepth() const { return -1.0; }
      virtual void setDepthOffset(float meters) {}
      virtual float depthOffset() const { return -1.0; }
      virtual void setAmbientWaterTemperature(float temperature) {}
      virtual float ambientWaterTemperature() const { return -1.0; }
      virtual void setWaterCurrentSpeed(float speed) {}
      virtual float waterCurrentSpeed() const { return -1.0; }
      virtual void setWaterCurrentDirection(float direction) {}
      virtual float waterCurrentDirection() const { return -1.0; }
      virtual void setTidalOffset(float meters) {}
      virtual float tidalOffset() const { return -1.0; }
      virtual void setTidalDirection(bool inOut) {}
      virtual bool tidalDirection() const { return false; }
      virtual void setThermoclineDepth(unsigned int layer, float depth) {}
      virtual float thermoclineDepth(unsigned int layer) const { return -1.0; }
      virtual void setThermoclinePermeability(
         unsigned int layer, float permeability) {}
      virtual float thermoclinePermeability(unsigned int layer) const { return -1.0; }

      virtual void loadDefaults(bool loadOnlyFactorySettings = false) {}
      virtual void restore() {}
      virtual void saveAsDefaults() {}
      virtual void exportSettings(const std::string& filename) {}
      virtual void importSettings(const std::string& filename) {}

   protected:
      virtual void slot_coordinateSystemChanged() {}
      virtual void slot_oceanLayerAdded(const makVrv::DtOceanLayer& layer) {}
      virtual void slot_oceanLayerToBeDeleted(const makVrv::DtOceanLayer& layer) {}
      virtual void slot_oceanLayerSeaLevelChanged(
         const makVrv::DtOceanLayer& layer, double seaLevel) {}
      virtual void slot_oceanLayerLodRangeChanged(
         const makVrv::DtOceanLayer& layer, int range) {}
      virtual void slot_surgeDepthChanged(double depth) {}
      virtual void slot_depthOffsetChanged(double offset) {}

   protected:
      makVrv::DtCloudLayer myCloudLayer;
      makVrv::DtEnvironmentInterface::PrecipitationType myPrecipitationType;
      makVrv::DtDe& myDe;

      makArchives::DtEnvironmentRecord myCurrentSettings;

      makVrv::DtEnvironmentList myEnvironmentList;
   };
}