include/ImplicitSurface.h

Go to the documentation of this file.

#ifndef __IMPLICIT_SURFACE_H__
#define __IMPLICIT_SURFACE_H__

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

#include <ngl/Vector.h>
#include <boost/math/special_functions/acosh.hpp>
#include <boost/math/special_functions/atanh.hpp>
#include <boost/math/special_functions/pow.hpp>

class ImplicitSurface
{
public:
friend class Obstacle;

  ImplicitSurface();

  ~ImplicitSurface();

  void sampleSphere(
                    int _resX,
                    int _resY,
                    int _resZ
                   );

  void sampleTorus(
                    int _resX,
                    int _resY,
                    int _resZ
                  );

  void sampleDoubleTorus(
                          int _resX,
                          int _resY,
                          int _resZ
                        );

  void sampleCayley(
                    int _resX,
                    int _resY,
                    int _resZ
                   );

  void sampleMandelbulb(
                        int _resX,
                        int _resY,
                        int _resZ
                       );

  void sampleHeart(
                    int _resX,
                    int _resY,
                    int _resZ
                  );

  void clearField(
                  int _resX,
                  int _resY,
                  int _resZ
                 );

  inline float* getScalarField() const {return &m_scalFieldData[0];}

  inline int getResX() const {return m_resX;}
  inline int getResY() const {return m_resY;}
  inline int getResZ() const {return m_resZ;}

private:
  float *m_scalFieldData;

  int m_resX;
  int m_resY;
  int m_resZ;

private:
  float sphereFunc(
                    ngl::Vector _coords,
                    float _r
                  );

  float torusFunc(
                  ngl::Vector _coords,
                  float _r,
                  float _R
                 );

  float doubleTorusFunc(
                        ngl::Vector _coords
                       );

  float cayleyFunc(
                    ngl::Vector _coords
                  );

  float mandelbulbFunc(
                        ngl::Vector _coords,
                        int         _n
                      );

  float heartFunc(
                  ngl::Vector _coords
                 );


  inline ngl::Vector normalizeTuple(
                                    int _i,
                                    int _j,
                                    int _k
                                   )
                                   {
                                    return ngl::Vector(
                                                        2.0f/m_resX*_i - 1.0f,
                                                        2.0f/m_resY*_j - 1.0f,
                                                        2.0f/m_resZ*_k - 1.0f
                                                      );
                                   }

  inline int index1D(
                      int _i,
                      int _j,
                      int _k
                    )
                    {
                      return _i + _j*m_resX + _k*m_resX*m_resY;
                    }
};

#endif // __IMPLICIT_SURFACE_H__