VisualField.h

#pragma once
 
#include <EnvironmentQuantityField.h>
#include <RefreshSchedule.h>
#include <ScalarFieldBake.h>
#include <cstddef>
#include <cstdint>
#include <fhsim/PrintDuringExec.h>
#include <fhsim/simobject/SimObject.h>
#include <memory>
#include <optional>
#include <string>
 
namespace environment
{
class EnvironmentProvider;
}
 
#ifdef FH_VISUALIZATION
#   include "visual/BakedFieldTexture.h"
 
#   include <OgreMaterial.h>
#endif
 
namespace environmentmodels
{
 
class VisualField : public SimObject
{
public:
   void FinalSetup(const double T, const double* const X, ISimObjectCreator* Creator) override;
 
   void OdeFcn(const double T, const double* const X, double* const XDot) const override;
 
   [[nodiscard]] util::Refresh RefreshMode() const;
 
protected:
   VisualField(std::string SimObjectName, ISimObjectCreator* Creator, int numAxes);
 
   ~VisualField() override;
 
   void ResolveCounts(const double extent[3], std::size_t budget, int counts[3]) const;
 
   void ValidateGridCounts(ISimObjectCreator* Creator, const int counts[3], const std::string& extentParameterName) const;
 
   [[nodiscard]] bool MaskInaccurate() const { return !m_showExtrapolated; }
 
   [[nodiscard]] bool ExpectsToSampleOnce() const;
 
   [[nodiscard]] bool MaySampleInTheBackground() const;
 
   [[nodiscard]] environment::field::ScalarField& Field() const;
 
   [[nodiscard]] double StartTime() const { return m_startTime; }
 
   [[nodiscard]] bool RefreshDue(double T, bool moved) const;
 
   void Refreshed(double T);
 
   util::BakedField SampleOver(double T, const util::SamplingBox& box);
 
   [[nodiscard]] double ValueMin() const { return m_valueMin; }
 
   [[nodiscard]] double ValueMax() const { return m_valueMax; }
 
#ifdef FH_VISUALIZATION
   void Show(const util::BakedField& baked);
 
   void SwapTextures(std::unique_ptr<visual::BakedFieldTexture> textures);
 
   Ogre::MaterialPtr CloneMaterial(const Ogre::String& baseMaterialName);
 
   void ApplyMaterialSettings() const;
 
   [[nodiscard]] const Ogre::MaterialPtr& Material() const { return m_material; }
#endif
 
   void Log(const std::string& message, fhsim::ELogLevel level) const;
 
private:
   void ReadQuantity(ISimObjectCreator* Creator);
 
   void ReadRefresh(ISimObjectCreator* Creator);
 
   void FixEncodingRange(double T, const util::SamplingBox& box);
 
   [[nodiscard]] std::uint64_t Revision() const;
 
   [[nodiscard]] bool UnchangedSinceLastSample() const;
 
   [[nodiscard]] bool ChangesWithWakesOnly() const;
 
   int m_numAxes; 
 
   util::FieldQuantity        m_quantity;  
   marenv::WaterVelocityParts m_terms;     
   double                     m_axis[3];   
   std::string                m_fieldName; 
 
   util::Refresh                        m_requestedRefresh; 
   double                               m_refreshPeriod;    
   std::optional<util::RefreshSchedule> m_schedule;         
 
   bool   m_hasSpacing;    
   bool   m_hasResolution; 
   double m_spacing[3];    
   int    m_resolution[3]; 
 
   double m_colorRange[2];   
   double m_visibleRange[2]; 
   double m_alphaRange[2];   
 
   bool m_hasColorRange;    
   bool m_hasVisibleRange;  
   bool m_showExtrapolated; 
 
   bool   m_encodingFixed; 
   double m_valueMin;      
   double m_valueMax;      
 
   double m_startTime; 
 
   environment::EnvironmentProvider* m_pEnvironment; 
   PrintDuringExec*                  m_print = nullptr; 
 
   std::shared_ptr<environment::field::ScalarField> m_field; 
 
#ifdef FH_VISUALIZATION
   std::unique_ptr<visual::BakedFieldTexture> m_texture;  
   Ogre::MaterialPtr                          m_material; 
#endif
};
 
} // namespace environmentmodels