MultiphaseFlowComponent.h

#pragma once
 
#include "EntityDefinition.h"
#include "Resources/Resources.h"
#include "Components/Core/DynamicComponent.h"
#include "Resources/VertexFormats.h"
 
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
 
#include <string>
 
namespace Cogs
{
  namespace Core
  {
    class MultiphaseFlowComponent : public DynamicComponent
    {
    public:
      std::vector<glm::vec3> trajectoryPoints;
      std::vector<float> radius;
      std::vector<glm::vec3> flowFraction;
      std::vector<float> wallValues;              // normalized 0..1
      float heightScale = 1.f;
      float radiusScale = 1.f;
      bool showWater = true;
      bool showOil = true;
      bool showGas = true;
      float unitScale = 1.f;
      std::string unitText = "m";
      bool updateNeeded = true;
      glm::vec3 waterColor;
      glm::vec3 oilColor;
      glm::vec3 gasColor;
      float fontSize = 20.f;
      bool showAxialExtents = true;
      bool showShadow = true;
      bool showGrid = true;
      bool centerMesh = true;
      bool showIndicatorRing = false;
      float indicatorRingPosition = 0.f;
      glm::vec3 indicatorRingColor;
      void updateFontSize();
 
      MultiphaseFlowComponent();
      void initialize(Context * context);
      void update();
 
      static void registerType();
 
      struct TrajectoryPoint
      {
        glm::vec3 pos;
        glm::vec3 flowFraction;
        float md = 0.0f;
        float radius = 0.0f;
        float wallValue = 0.0f;
        glm::quat rotation;
      };
 
    private:
      struct FlowFractionData
      {
          float widthWaterOil = 0.f;
          float widthOilGas = 0.f;
          float heightWaterOil = 0.f;
          float heightOilGas = 0.f;
          float water = 0.f;
          float oil = 0.f;
          float gas = 0.f;
      };
 
      struct ControlPoint
      {
          glm::vec3 position;
          float radius = 1.f;
          glm::quat rotation;
          glm::vec3 direction;
          FlowFractionData flow;
          float wall = 0.f;
          bool invertedFlow = false;          // Inverted flow for pipes loops.
          float invertedFlowRatio = 0.f;
          bool annularFlow = false;
          float annularFlowRatio = 0.f;
          glm::vec3 rotationUpVector = glm::vec3(0, 1, 0);
      };
 
      struct Vertex
      {
        glm::vec3 position;
        glm::vec4 normalAndOpacity;
 
        static VertexFormatHandle getVertexFormat()
        {
          const VertexElement elements[] = {
            { 0, DataFormat::X32Y32Z32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 },
            { 3 * sizeof(float), DataFormat::X32Y32Z32W32_FLOAT, ElementSemantic::Normal, 0, InputType::VertexData, 0 },
          };
 
          static VertexFormatHandle vertexFormat = Cogs::VertexFormats::createVertexFormat(elements, 2);
 
          return vertexFormat;
        }
      };
 
      struct WallVertex
      {
        glm::vec3 position;
        glm::vec4 normalAndOpacity;
        glm::vec3 color;
 
        static VertexFormatHandle getVertexFormat()
        {
          const VertexElement elements[] = {
            { 0, DataFormat::X32Y32Z32_FLOAT, ElementSemantic::Position, 0, InputType::VertexData, 0 },
            { 3 * sizeof(float), DataFormat::X32Y32Z32W32_FLOAT, ElementSemantic::Normal, 0, InputType::VertexData, 0 },
            { 7 * sizeof(float), DataFormat::X32Y32Z32_FLOAT, ElementSemantic::Color, 0, InputType::VertexData, 0 },
          };
 
          static VertexFormatHandle vertexFormat = Cogs::VertexFormats::createVertexFormat(elements, 3);
 
          return vertexFormat;
        }
      };
 
      enum MeshType
      {
          // Opaque
          StratifiedWater,
          AnnularWater,
          StratifiedOil,
 
          // Transparent
          AnnularOil,
          StratifiedGas,
          AnnularGas,
 
          Wall,
 
          Shadow,
 
          First = 0,
          Last = 7
      };
 
    private:
      static bool isStratified(MeshType liquidType);
      static bool isAnnular(MeshType liquidType);
      static unsigned int getNumOfSegmentsInCrossSection(MeshType liquidType);
 
      void createMeshEntity(EntityPtr& mesh, MeshType liquidType);
      void updateMaterial(EntityPtr mesh, MeshType liquidType);
      void generateMultiphaseFlowMesh(Mesh* mesh, const std::vector<ControlPoint>& controlPoints, MeshType liquidType);
 
      void createGridEntity();
      void createTextEntity();
      void createIndicatorRing();
 
      void updateGroundGrid();
      void updateAxisAnnotations();
      void updateIndicatorRing(const std::vector<TrajectoryPoint>& trajectory);
 
      void generateExtrusionVertices(std::vector<Vertex>& vertexBuffer, std::vector<unsigned int>& indexBuffer, const std::vector<ControlPoint>& controlPoints, MeshType liquidType);
      void generateExtrusionVerticesWall(std::vector<WallVertex>& vertexBuffer, std::vector<unsigned int>& indexBuffer, const std::vector<ControlPoint>& controlPoints, MeshType liquidType);
      void generateClosingCaps(std::vector<Vertex>& vertexBuffer, std::vector<unsigned int>& indexBuffer, const ControlPoint& controlPoint, MeshType liquidType);
 
      void transformCrossection(float ratio, float alpha, std::vector<Vertex>& vertexBuffer, const ControlPoint& controlPoint, MeshType liquidType, bool isClosingCap = false);
 
      void removeDuplicatedPoints(std::vector<TrajectoryPoint>& points);
      void applyScaling(std::vector<TrajectoryPoint>& points);
      void center(std::vector<TrajectoryPoint>& points);
 
      void updateMeshes();
      void updateShadowVisibility();
 
      void finalizeControlPoints(std::vector<ControlPoint>& controlPoints);
 
      static glm::vec3 wallValueToColor(const ControlPoint& controlPoint);
 
      static void calculateNormals(std::vector<Vertex>& vertexBuffer, std::vector<unsigned int>& indexBuffer);
 
    private:
      enum AnnotationAxis
      {
          X,
          YMin,
          YMax,
          Y,
          Z,
          AxisFirst = X,
          AxisLast = Z
      };
 
    private:
      Context* context = nullptr;
      Material* mainMaterial = nullptr;
      VariableKey diffuseColorMaterialPropertyKey;
      VariableKey emissiveColorMaterialPropertyKey;
      VariableKey specularColorMaterialPropertyKey;
      EntityPtr meshEntity[MeshType::Last + 1];
      EntityPtr wallEntity;
      EntityPtr groundGridMeshEntity;
      EntityPtr annotationAxisMeshEntity;
      EntityPtr indicatorRingEntity;
 
      EntityPtr textEntity[AnnotationAxis::AxisLast + 1];
 
      glm::vec3 geometryMin;
      glm::vec3 geometryMax;
 
      glm::vec3 scaledTrajectoryMin;
      glm::vec3 scaledTrajectoryMax;
 
      float currentFontSize = -1.f;
 
      bool currentShowAxialExtents = true;
      bool currentShowGrid = true;
      bool currentCenterMesh = true;
      bool currentShowIndicatorRing = false;
    };
  } // namespace Core
} // namespace Cogs
 
template<> inline Cogs::StringView getName<Cogs::Core::MultiphaseFlowComponent>() { return "MultiphaseFlowComponent"; }