include/FluidEngine.h

Go to the documentation of this file.

#ifndef __FLUID_ENGINE_H__
#define __FLUID_ENGINE_H__

//-----------------------------------------------------------
//-----------------------------------------------------------

#include <ngl/TransformStack.h>
#include "ComputeEngine.h"
#include "GasSolver.h"
#include "ImageUnitStack.h"
#include "VertexArrayObject.h"
#include "VolumeMesher.h"
#include "VolumeSlicer.h"

class FluidEngine
{
public:
  enum RenderField{
                    VELOCITY,
                    PRESSURE,
                    TEMPERATURE,
                    DENSITY
                  };

  FluidEngine(
              int _simResX,
              int _simResY,
              int _simResZ
             );

  ~FluidEngine();

  void init();

  void updateOutputs();

  void drawMesh(
                  RenderField          _field,
                  ngl::TransformStack &_transformStack
               );

  void setIsoLevel(
                    float _isoLevel
                  );

  void setSamplingChannel(
                          int _channelIndex
                         );

  void setMeshingMethod(
                         int _meshingMethod
                       );

  void setMeshColour(
                      float _r,
                      float _g,
                      float _b
                    );

  void drawSlice(
                  RenderField          _field,
                  ngl::TransformStack &_transformStack
                );

  void setSliceOpacity(
                        float _opacity
                      );

  void setSlicePos(
                    int _slicePos
                  );

  void drawObstacles(
                      ngl::TransformStack &_transformStack
                    );

  void drawContainer(
                      ngl::TransformStack &_transformStack
                    );

  void passViewProjectionMatrix(
                                ngl::Matrix _modelView,
                                ngl::Matrix _projection
                               );

  int getSimResX() const {return m_simResX;}
  int getSimResY() const {return m_simResY;}
  int getSimResZ() const {return m_simResZ;}

  void resetResolution();

  inline GasSolver* getGasSolver() const {return m_gasSolver;}

  void setObstacleGeometry(
                            int _geoIndex
                          );

  inline void setCellSize(
                          float _cellSize
                         )
                         {
                          m_gasSolver->setCellSize(_cellSize);
                         }

  inline void setSplatRadius(
                              float _splatRadius
                            )
                            {

                              m_gasSolver->setSplatRadius(_splatRadius);
                            }

  inline void setAmbientTemperature(
                                    float _ambientTemperature
                                   )
                                   {
                                    m_gasSolver->setAmbientTemperature(_ambientTemperature);
                                   }

  inline void setImpulseTemperature(
                                    float _impulseTemperature
                                   )
                                   {
                                    m_gasSolver->setImpulseTemperature(_impulseTemperature);
                                   }

  inline void setImpulseDensity(
                                float _impulseDensity
                               )
                               {
                                m_gasSolver->setImpulseDensity(_impulseDensity);
                               }

  inline void setImpulsePosition(
                                  float _posX,
                                  float _posY,
                                  float _posZ
                                )
                                {
                                  m_gasSolver->setImpulsePosition(_posX, _posY, _posZ);
                                }

  inline void setPoissonIterations(
                                    int _numPoissonIterations
                                  )
                                  {
                                    m_gasSolver->setPoissonIterations(_numPoissonIterations);
                                  }

  inline void setTimestep(
                          float _timestep
                         )
                         {
                           m_gasSolver->setTimestep(_timestep);
                         }

  inline void setBuoyancyLift(
                                float _buoyancyLift
                              )
                              {
                                m_gasSolver->setBuoyancyLift(_buoyancyLift);
                              }

  inline void setGasWeight(
                            float _gasWeight
                          )
                          {
                            m_gasSolver->setGasWeight(_gasWeight);
                          }

  inline void setBuoyancyDirection(
                                    float _dirX,
                                    float _dirY,
                                    float _dirZ
                                  )
                                  {
                                    m_gasSolver->setBuoyancyDirection(_dirX, _dirY, _dirZ);
                                  }

  inline void togglePeriodicNoise(
                                  bool _enablePeriodicNoise
                                 )
                                 {
                                  m_gasSolver->togglePeriodicNoise(_enablePeriodicNoise);
                                 }

  inline void setNoiseVariance(
                                float _noiseVarianceX,
                                float _noiseVarianceY,
                                float _noiseVarianceZ
                              )
                              {
                                m_gasSolver->setNoiseVariance(
                                                              _noiseVarianceX,
                                                              _noiseVarianceY,
                                                              _noiseVarianceZ
                                                             );
                              }

  inline void setNoiseDrivingFunc(
                                  int _funcIndexX,
                                  int _funcIndexY,
                                  int _funcIndexZ
                                 )
                                 {
                                  m_gasSolver->setNoiseDrivingFunc(
                                                                    _funcIndexX,
                                                                    _funcIndexY,
                                                                    _funcIndexZ
                                                                  );
                                 }


  inline void setTemperatureDissipation(
                                        float _temperatureDissipation
                                       )
                                       {
                                         m_gasSolver->setTemperatureDissipation(_temperatureDissipation);
                                       }

  inline void setDensityDissipation(
                                    float _densityDissipation
                                   )
                                   {
                                     m_gasSolver->setDensityDissipation(_densityDissipation);
                                   }

  inline void setVelocityDissipation(
                                      float _velocityDissipation
                                    )
                                    {
                                      m_gasSolver->setVelocityDissipation(_velocityDissipation);
                                    }

private:
  int m_simResX;
  int m_simResY;
  int m_simResZ;

  ComputeEngine* m_compute;
  ImageUnitStack* m_imageUnitStack;
  GasSolver* m_gasSolver;
  VolumeMesher* m_volumeMesher;
  VolumeSlicer* m_volumeSlicer;

  float m_meshIsoLevel;
  int m_meshSamplingChannel;
  ngl::Colour* m_meshColour;

  VertexArrayObject* m_containerVAO;
};

#endif // __FLUID_ENGINE_H__