include/VolumeMesher.h

Go to the documentation of this file.

#ifndef __VOLUME_MESHER_H__
#define __VOLUME_MESHER_H__

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

#include <ngl/Colour.h>
#include <ngl/TransformStack.h>
#include <ngl/Matrix.h>
#include "GLUtil.h"
#include "ImageUnitStack.h"
#include "Texture1D.h"
#include "Texture2D.h"
#include "Texture3D.h"
#include "VertexArrayObject.h"

class VolumeMesher
{
public:

  enum MeshingMethod{ MARCHING_CUBES, DIVIDING_CUBES };

  VolumeMesher(
                int             _resX,
                int             _resY,
                int             _resZ,
                ImageUnitStack* _imageUnitStack
              );

  ~VolumeMesher();

  void init();

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

  inline void setResolution(
                            int _resX,
                            int _resY,
                            int _resZ
                           )
                           {
                            m_resX = _resX;
                            m_resY = _resY;
                            m_resZ = _resZ;

                            m_samplingStepX = 2.0f/m_resX;
                            m_samplingStepY = 2.0f/m_resY;
                            m_samplingStepZ = 2.0f/m_resZ;
                           }

  inline float getSamplingStepX() const {return m_samplingStepX;}
  inline float getSamplingStepY() const {return m_samplingStepY;}
  inline float getSamplingStepZ() const {return m_samplingStepZ;}

  void drawMesh(
                Texture3D*   _texture3D,
                float        _isoLevel,
                int          _samplingChannel,
                ngl::Colour* _colour,
                ngl::Matrix  _modelMatrix,
                bool         _inverseNormals = false
               );

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

  void setMeshingMethod(
                        MeshingMethod _meshingMethod
                       );

  void passViewProjectionMatrix(
                                ngl::Matrix _modelViewMatrix,
                                ngl::Matrix _projectionMatrix
                               );

private:
  static int s_edgeTable[256];
  static int s_triTable[256][16];

  float* m_grid;

  int m_resX;
  int m_resY;
  int m_resZ;

  float m_samplingStepX;
  float m_samplingStepY;
  float m_samplingStepZ;

  ImageUnitStack* m_imageUnitStack;

  MeshingMethod m_meshingMethod;

  Texture1D* m_edgeTableTex;
  Texture2D* m_triTableTex;

  VertexArrayObject* m_marchGridVAO;

private:
  void createMarchingGrid();
};

#endif // __VOLUME_MESHER_H__