FlowPlane.h

#pragma once
#ifdef FH_VISUALIZATION
 
#   include <OgreManualObject.h>
#   include <OgreRoot.h>
#   include <OgreSceneNode.h>
#   include <OgreSubMesh.h>
#   include <array>
#   include <fhsim_environment/EnvironmentProvider.h>
#   include <functional>
#   include <vector>
 
namespace visual
{
 
struct FlowPlaneSettings
{
   double position[3] = {0.0, 0.0, 0.0};
   double localX[3] = {1.0, 0.0, 0.0};
   double localY[3] = {0.0, 1.0, 0.0};
   double size[2] = {50.0, 50.0};
   int vertexCounts[2] = {50, 50};
   double visibleRange[2] = {0.0, 1.0};
   double colorRange[2] = {0.0, 1.0};
   double alphaRange[2] = {0.3, 0.6};
};
 
using ComputeFunction = std::function<double(double T, const double pos[3])>;
 
class FlowPlane
{
public:
   FlowPlane(Ogre::Root*                   ogreRoot,
         environment::EnvironmentProvider* provider,
         const FlowPlaneSettings&          settings,
         ComputeFunction                   computeFunc = nullptr);
 
   ~FlowPlane()                           = default;
   FlowPlane(const FlowPlane&)            = delete;
   FlowPlane& operator=(const FlowPlane&) = delete;
 
   void Update(double T);
 
   void SetTransform(const double position[3], const double localX[3], const double localY[3]);
 
   void SetComputeFunction(ComputeFunction func);
 
private:
   void UpdateVertexPositions();
 
   void UpdateOgreNodeOrientation();
 
   environment::EnvironmentProvider* m_provider;
   Ogre::SceneNode* m_node;
   Ogre::SubMesh* m_subMesh;
   int m_vertexCounts[2];
   double m_size[2];
   double m_position[3];
   double m_localX[3];
   double m_localY[3];
   double m_speedMin;
   double m_speedMax;
   std::vector<std::array<double, 3>> m_vertexWorldPos;
   ComputeFunction m_computeFunction;
   Ogre::Entity* m_entity;
   int m_defaultRenderQueueGroup; 
};
 
} // namespace visual
#endif // FH_VISUALIZATION