vtkOpenGLFluidMapper.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkOpenGLFluidMapper_h
#define vtkOpenGLFluidMapper_h
 
#include "vtkAbstractVolumeMapper.h"
 
#include "vtkOpenGLHelper.h"           // used for ivars
#include "vtkRenderingOpenGL2Module.h" // For export macro
#include "vtkShader.h"                 // for methods
#include "vtkSmartPointer.h"           // for ivars
 
#include <map> //for methods
 
class vtkMatrix3x3;
class vtkMatrix4x4;
class vtkOpenGLFramebufferObject;
class vtkOpenGLRenderWindow;
class vtkOpenGLState;
class vtkOpenGLQuadHelper;
class vtkOpenGLVertexBufferObjectGroup;
class vtkPolyData;
class vtkTextureObject;
 
class VTKRENDERINGOPENGL2_EXPORT vtkOpenGLFluidMapper : public vtkAbstractVolumeMapper
{
public:
  static vtkOpenGLFluidMapper* New();
  vtkTypeMacro(vtkOpenGLFluidMapper, vtkAbstractVolumeMapper);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  void SetInputData(vtkPolyData* in);
  vtkPolyData* GetInput();
 
 
  vtkSetMacro(ScalarVisibility, bool);
  vtkGetMacro(ScalarVisibility, bool);
  vtkBooleanMacro(ScalarVisibility, bool);
 
 
  vtkSetMacro(ParticleRadius, float);
  vtkGetMacro(ParticleRadius, float);
 
 
  vtkSetMacro(SurfaceFilterIterations, uint32_t);
  vtkGetMacro(SurfaceFilterIterations, uint32_t);
 
 
  vtkSetMacro(ThicknessAndVolumeColorFilterIterations, uint32_t);
  vtkGetMacro(ThicknessAndVolumeColorFilterIterations, uint32_t);
 
 
  vtkSetMacro(SurfaceFilterRadius, uint32_t);
  vtkGetMacro(SurfaceFilterRadius, uint32_t);
 
 
  vtkSetMacro(ThicknessAndVolumeColorFilterRadius, float);
  vtkGetMacro(ThicknessAndVolumeColorFilterRadius, float);
 
  enum FluidSurfaceFilterMethod
  {
    BilateralGaussian = 0,
    NarrowRange,
    // New filter method can be added here,
    NumFilterMethods
  };
 
 
  vtkSetMacro(SurfaceFilterMethod, vtkOpenGLFluidMapper::FluidSurfaceFilterMethod);
  vtkGetMacro(SurfaceFilterMethod, vtkOpenGLFluidMapper::FluidSurfaceFilterMethod);
 
  void SetNarrowRangeFilterParameters(float lambda, float mu)
  {
    this->NRFilterLambda = lambda;
    this->NRFilterMu = mu;
  }
 
  void SetBilateralGaussianFilterParameter(float sigmaDepth)
  {
    this->BiGaussFilterSigmaDepth = sigmaDepth;
  }
 
  enum FluidDisplayMode
  {
    UnfilteredOpaqueSurface = 0,
    FilteredOpaqueSurface,
    UnfilteredSurfaceNormal,
    FilteredSurfaceNormal,
    TransparentFluidVolume,
    NumDisplayModes
  };
 
 
  vtkSetMacro(DisplayMode, vtkOpenGLFluidMapper::FluidDisplayMode);
  vtkGetMacro(DisplayMode, vtkOpenGLFluidMapper::FluidDisplayMode);
 
 
  vtkSetVector3Macro(AttenuationColor, float);
  vtkGetVector3Macro(AttenuationColor, float);
 
 
  vtkSetVector3Macro(OpaqueColor, float);
  vtkGetVector3Macro(OpaqueColor, float);
 
 
  vtkSetMacro(ParticleColorPower, float);
  vtkGetMacro(ParticleColorPower, float);
 
 
  vtkSetMacro(ParticleColorScale, float);
  vtkGetMacro(ParticleColorScale, float);
 
 
  vtkSetMacro(AttenuationScale, float);
  vtkGetMacro(AttenuationScale, float);
 
 
  vtkSetMacro(AdditionalReflection, float);
  vtkGetMacro(AdditionalReflection, float);
 
 
  vtkSetMacro(RefractionScale, float);
  vtkGetMacro(RefractionScale, float);
 
 
  vtkSetMacro(RefractiveIndex, float);
  vtkGetMacro(RefractiveIndex, float);
 
  void Render(vtkRenderer* ren, vtkVolume* vol) override;
 
  void ReleaseGraphicsResources(vtkWindow* w) override;
 
protected:
  vtkOpenGLFluidMapper();
  ~vtkOpenGLFluidMapper() override;
 
  void UpdateDepthThicknessColorShaders(
    vtkOpenGLHelper& glHelper, vtkRenderer* renderer, vtkVolume* vol);
 
  void SetDepthThicknessColorShaderParameters(
    vtkOpenGLHelper& glHelper, vtkRenderer* renderer, vtkVolume* vol);
 
  void SetupBuffers(vtkOpenGLRenderWindow* const renderWindow);
 
  void RenderParticles(vtkRenderer* renderer, vtkVolume* vol);
 
  // Public parameters, their usage are stated at their Get/Set functions
  // ======>>>>>
  float ParticleRadius = 1.0f;
 
  FluidSurfaceFilterMethod SurfaceFilterMethod = FluidSurfaceFilterMethod::NarrowRange;
  uint32_t SurfaceFilterIterations = 3u;
  uint32_t SurfaceFilterRadius = 5u;
  float NRFilterLambda = 10.0f;
  float NRFilterMu = 1.0f;
  float BiGaussFilterSigmaDepth = 10.0f;
 
  uint32_t ThicknessAndVolumeColorFilterIterations = 3u;
  uint32_t ThicknessAndVolumeColorFilterRadius = 10u;
 
  FluidDisplayMode DisplayMode = FluidDisplayMode::TransparentFluidVolume;
 
  float OpaqueColor[3]{ 0.0f, 0.0f, 0.95f };
  float AttenuationColor[3]{ 0.5f, 0.2f, 0.05f };
  float ParticleColorPower = 0.1f;
  float ParticleColorScale = 1.0f;
  float AttenuationScale = 1.0f;
  float AdditionalReflection = 0.0f;
  float RefractionScale = 1.0f;
  float RefractiveIndex = 1.33f;
 
  bool ScalarVisibility = false;
  bool InDepthPass = true;
 
  // Private parameters ======>>>>>
 
  // Indicate that the input data has a color buffer
  bool HasVertexColor = false;
 
  // Cache viewport dimensions
  int ViewportX;
  int ViewportY;
  int ViewportWidth;
  int ViewportHeight;
 
  // Cache camera parameters
  vtkMatrix4x4* CamWCVC;
  vtkMatrix3x3* CamInvertedNorms;
  vtkMatrix4x4* CamVCDC;
  vtkMatrix4x4* CamWCDC;
  vtkMatrix4x4* CamDCVC;
  vtkTypeBool CamParallelProjection;
 
  // Frame buffers
  vtkSmartPointer<vtkOpenGLFramebufferObject> FBFluidEyeZ;
  vtkSmartPointer<vtkOpenGLFramebufferObject> FBThickness;
  vtkSmartPointer<vtkOpenGLFramebufferObject> FBFilterThickness;
  vtkSmartPointer<vtkOpenGLFramebufferObject> FBCompNormal;
  vtkSmartPointer<vtkOpenGLFramebufferObject> FBFilterDepth;
 
  // Screen quad render
  vtkOpenGLQuadHelper* QuadFluidDepthFilter[NumFilterMethods]{ nullptr, nullptr };
  vtkOpenGLQuadHelper* QuadThicknessFilter = nullptr;
  vtkOpenGLQuadHelper* QuadFluidNormal = nullptr;
  vtkOpenGLQuadHelper* QuadFinalBlend = nullptr;
 
  // The VBO and its layout for rendering particles
  vtkSmartPointer<vtkOpenGLVertexBufferObjectGroup> VBOs;
  vtkTimeStamp VBOBuildTime; // When was the OpenGL VBO updated?
  vtkOpenGLHelper GLHelperDepthThickness;
 
  // Texture buffers
  enum TextureBuffers
  {
    OpaqueZ = 0,
    OpaqueRGBA,
    FluidZ,
    FluidEyeZ,
    SmoothedFluidEyeZ,
    FluidThickness,
    SmoothedFluidThickness,
    FluidNormal,
    NumTexBuffers
  };
 
  // These are optional texture buffers
  enum OptionalTextureBuffers
  {
    Color = 0,
    SmoothedColor,
    NumOptionalTexBuffers
  };
 
  vtkTextureObject* TexBuffer[NumTexBuffers];
  vtkTextureObject* OptionalTexBuffer[NumOptionalTexBuffers];
  vtkMatrix4x4* TempMatrix4;
 
private:
  vtkOpenGLFluidMapper(const vtkOpenGLFluidMapper&) = delete;
  void operator=(const vtkOpenGLFluidMapper&) = delete;
};
 
#endif