include/GasSolver.h

Go to the documentation of this file.

#ifndef __GAS_SOLVER_H__
#define __GAS_SOLVER_H__

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

#include <ngl/Vector.h>
#include "ComputeEngine.h"
#include "GLUtil.h"
#include "ImageUnitStack.h"
#include "Obstacle.h"
#include "PingPongVolume.h"

class GasSolver
{
public:

  enum DrivingFunction{ NONE, SIN, COS, TAN };

  GasSolver(
            int             _w,
            int             _h,
            int             _d,
            ComputeEngine*  _compute,
            ImageUnitStack* _imageUnitStack
           );

  ~GasSolver();

  void init();

  void update();

  void updateObstacleData();

  inline PingPongVolume* getVelocity() const {return m_velocityVol;}
  inline PingPongVolume* getPressure() const {return m_pressureVol;}
  inline PingPongVolume* getTemperature() const {return m_temperatureVol;}
  inline PingPongVolume* getDensity() const {return m_densityVol;}

  inline Obstacle* getObstacles() const {return m_obstacles;}

  inline void setCellSize(
                          float _cellSize
                         )
                         {
                          m_cellSize = _cellSize;
                         }

  inline void setSplatRadius(
                              float _splatRadius
                            )
                            {
                              m_splatRadius = _splatRadius;
                            }

  inline void setAmbientTemperature(
                                    float _ambientTemperature
                                   )
                                   {
                                    m_ambientTemperature = _ambientTemperature;
                                   }

  inline void setImpulseTemperature(
                                    float _impulseTemperature
                                   )
                                   {
                                    m_impulseTemperature = _impulseTemperature;
                                   }

  inline void setImpulseDensity(
                                float _impulseDensity
                               )
                               {
                                m_impulseDensity = _impulseDensity;
                               }

  inline void setImpulsePosition(
                                  float _posX,
                                  float _posY,
                                  float _posZ
                                )
                                {
                                  m_impulsePosition->set(ngl::Vector(_posX, _posY, _posZ));
                                }

  inline void setPoissonIterations(
                                    int _numPoissonIterations
                                  )
                                  {
                                    m_numPoissonIterations = _numPoissonIterations;
                                  }

  inline void setTimestep(
                          float _timestep
                         )
                         {
                           m_timestep = _timestep;
                         }

  inline void setBuoyancyLift(
                                float _buoyancyLift
                              )
                              {
                                m_buoyancyLift = _buoyancyLift;
                              }

  inline void setBuoyancyDirection(
                                    float _dirX,
                                    float _dirY,
                                    float _dirZ
                                  )
                                  {
                                    m_buoyancyDirection->set(ngl::Vector(_dirX, _dirY, _dirZ));
                                  }

  inline void togglePeriodicNoise(
                                  bool _enablePeriodicNoise
                                 )
                                 {
                                  m_enablePeriodicNoise = _enablePeriodicNoise;
                                 }

  inline void setNoiseVariance(
                                        float _noiseVarianceX,
                                        float _noiseVarianceY,
                                        float _noiseVarianceZ
                                      )
                                      {
                                        m_noiseVarianceX = _noiseVarianceX;
                                        m_noiseVarianceY = _noiseVarianceY;
                                        m_noiseVarianceZ = _noiseVarianceZ;
                                      }

  void setNoiseDrivingFunc(
                            int _funcIndexX,
                            int _funcIndexY,
                            int _funcIndexZ
                          );

  inline void setGasWeight(
                            float _gasWeight
                          )
                          {
                            m_gasWeight = _gasWeight;
                          }

  inline void setTemperatureDissipation(
                                        float _temperatureDissipation
                                       )
                                       {
                                         m_temperatureDissipation = _temperatureDissipation;
                                       }

  inline void setDensityDissipation(
                                    float _densityDissipation
                                   )
                                   {
                                     m_densityDissipation = _densityDissipation;
                                   }

  inline void setVelocityDissipation(
                                      float _velocityDissipation
                                    )
                                    {
                                      m_velocityDissipation = _velocityDissipation;
                                    }

private:
  int m_gridWidth;
  int m_gridHeight;
  int m_gridDepth;

  size_t m_gridBytes;

  ComputeEngine* m_compute;
  ImageUnitStack* m_imageUnitStack;

  float m_cellSize;
  float m_splatRadius;

  float m_ambientTemperature;
  float m_impulseTemperature;
  float m_impulseDensity;
  int m_numPoissonIterations;
  float m_timestep;
  float m_buoyancyLift;
  float m_gasWeight;
  ngl::Vector* m_buoyancyDirection;

  bool m_enablePeriodicNoise;
  float m_noiseVarianceX;
  float m_noiseVarianceY;
  float m_noiseVarianceZ;

  DrivingFunction m_drivingFunctionX;
  DrivingFunction m_drivingFunctionY;
  DrivingFunction m_drivingFunctionZ;

  float m_gradientScale;
  float m_temperatureDissipation;
  float m_velocityDissipation;
  float m_densityDissipation;
  ngl::Vector* m_impulsePosition;

  PingPongVolume* m_velocityVol;
  PingPongVolume* m_pressureVol;
  PingPongVolume* m_temperatureVol;
  PingPongVolume* m_densityVol;
  Obstacle* m_obstacles;

private:
  void advection(
                  cl_mem  _fieldW,
                  cl_mem  _fieldR,
                  float   _dissipation,
                  size_t* _globalDim,
                  size_t* _localDim
                );

  void buoyancyApplication(
                            size_t* _globalDim,
                            size_t* _localDim
                          );

  void impulseApplication(
                          size_t* _globalDim,
                          size_t* _localDim
                         );

  void pressureProjection(
                          size_t* _globalDim,
                          size_t* _localDim
                         );

  void periodicNoise();

  void attachGLBuffers();

  void detachGLBuffers();
};

#endif // __GAS_SOLVER_H__