dox/Rendering/VolumeOpenGL/vtkOpenGLGPUVolumeRayCastMapper.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkOpenGLGPUVolumeRayCastMapper.h

  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 __vtkOpenGLGPUVolumeRayCastMapper_h
#define __vtkOpenGLGPUVolumeRayCastMapper_h

#include "vtkRenderingVolumeOpenGLModule.h" // For export macro
#include "vtkGPUVolumeRayCastMapper.h"

class vtkVolume;
class vtkRenderer;
class vtkOpenGLExtensionManager;
class vtkMatrix4x4;
class vtkUnsupportedRequiredExtensionsStringStream; // Pimpl
class vtkMapDataArrayTextureId; // Pimpl
class vtkMapMaskTextureId; // Pimpl
class vtkPolyData;
class vtkClipConvexPolyData;
class vtkClipPolyData;
class vtkTessellatedBoxSource;

class vtkOpacityTable; // internal class.
class vtkRGBTable; // internal class.
class vtkKWScalarField; // internal class.
class vtkKWMask; // internal class.

class vtkOpacityTables; // Pimpl
class vtkDensifyPolyData;
class vtkStdString;

class vtkShaderProgram2;
class vtkShader2;

class VTKRENDERINGVOLUMEOPENGL_EXPORT vtkOpenGLGPUVolumeRayCastMapper
  : public vtkGPUVolumeRayCastMapper
{
public:
  static vtkOpenGLGPUVolumeRayCastMapper *New();
  vtkTypeMacro(vtkOpenGLGPUVolumeRayCastMapper,vtkGPUVolumeRayCastMapper);
  virtual void PrintSelf(ostream& os, vtkIndent indent);


  virtual int IsRenderSupported(vtkRenderWindow *window,
                                vtkVolumeProperty *property);

  virtual void ReleaseGraphicsResources(vtkWindow *window);

  static const char *OpenGLErrorMessage(unsigned int errorCode);

  static void PrintError(const char *headerMessage);

protected:
  vtkOpenGLGPUVolumeRayCastMapper();
  ~vtkOpenGLGPUVolumeRayCastMapper();

  // The render method called by the superclass
  virtual void GPURender(vtkRenderer *ren,
                         vtkVolume *vol);

  // Methods called by the AMR Volume Mapper.
  virtual void PreRender(vtkRenderer *ren,
                         vtkVolume *vol,
                         double datasetBounds[6],
                         double scalarRange[2],
                         int numberOfScalarComponents,
                         unsigned int numberOfLevels);

  // \pre input is up-to-date
  virtual void RenderBlock(vtkRenderer *ren,
                           vtkVolume *vol,
                           unsigned int level);

  virtual void PostRender(vtkRenderer *ren,
                          int numberOfScalarComponents);


  int TestRequiredExtension(vtkOpenGLExtensionManager *extensions,
                            const char *extensionName);

  void LoadExtensions(vtkRenderWindow *window);

  void CreateOpenGLObjects(vtkRenderer *ren);

  int AllocateFrameBuffers(vtkRenderer *ren);


  int LoadScalarField(vtkImageData *input,
                      vtkImageData *maskInput,
                      int textureExtent[6],
                      vtkVolume *volume);


  int UpdateColorTransferFunction(vtkVolume *vol,
                                  int numberOfScalarComponents);


  int UpdateOpacityTransferFunction(vtkVolume *vol,
                                    int numberOfScalarComponents,
                                    unsigned int level);

  void SetupRender(vtkRenderer *ren, vtkVolume *vol);


  void ClipBoundingBox(vtkRenderer *ren,
                       double worldBounds[6],
                       vtkVolume *vol);


  int RenderClippedBoundingBox(int tcoordFlag,
                               size_t currentBlock,
                               size_t numberOfBlocks,
                               vtkRenderWindow *renWin);

  void CopyFBOToTexture();

  void CleanupRender();

  void RenderTextureToScreen(vtkRenderer *ren);

  int PowerOfTwoGreaterOrEqual(int x);

  void CheckFrameBufferStatus();

  vtkStdString BufferToString(int buffer);

  void DisplayReadAndDrawBuffers();

  void DisplayFrameBufferAttachments();

  void DisplayFrameBufferAttachment(unsigned int uattachment);


  void BuildProgram(vtkRenderWindow *w,
                    int parallelProjection,
                    int raycastMethod,
                    int shadeMethod,
                    int componentMethod);

  void GetLightingStatus();

  void ComputeReductionFactor(double allocatedTime);


  void RenderWholeVolume(vtkRenderer *ren,
                         vtkVolume *vol);


  void RenderRegions(vtkRenderer *ren,
                     vtkVolume *vol);

  // Return abort status (true==abort)
  int RenderSubVolume(vtkRenderer *ren,
                      double bounds[6],
                      vtkVolume *vol);

  void LoadProjectionParameters(vtkRenderer *ren,
                                vtkVolume *vol);

  void ComputeNumberOfCroppingRegions();

  void GetTextureFormat(vtkImageData *input,
                        unsigned int *internalFormat,
                        unsigned int *format,
                        unsigned int *type,
                        int *componentSize);

  bool TestLoadingScalar(unsigned int internalFormat,
                         unsigned int format,
                         unsigned int type,
                         int textureSize[3],
                         int componentSize);

  void SlabsFromDatasetToIndex(double slabsDataSet[6],
                               double slabsPoints[6]);

  void SlabsFromIndexToDataset(double slabsPoints[6],
                               double slabsDataSet[6]);

  const char *GetEnabledString(unsigned char value);
  void GetOpenGLState();

  void DebugDisplayBox(vtkPolyData *box);

  void UpdateNoiseTexture();


  double ComputeMinimalSampleDistancePerPixel(vtkRenderer *renderer,
                                              vtkVolume *volume);

  virtual void GetReductionRatio(double ratio[3]);

  int NumberOfCroppingRegions;

  // World coordinates of each corner of the dataset.
  double BoundingBox[8][3];

  // Used during the clipping process.
  vtkPolyData *PolyDataBoundingBox;
  vtkPlaneCollection *Planes;
  vtkPlane *NearPlane;

  vtkClipConvexPolyData *Clip;
  vtkMatrix4x4 *InvVolumeMatrix;

  vtkDensifyPolyData *Densify;

  int OpenGLObjectsCreated;
  int NumberOfFrameBuffers;

  unsigned int FrameBufferObject;
  unsigned int DepthRenderBufferObject;

  // 3D scalar texture +1D color+1D opacity+2D grabbed depth buffer
  // +1 2D colorbuffer.
  unsigned int TextureObjects[5];
  // used in MIP Mode (2 needed for ping-pong technique)
  unsigned int MaxValueFrameBuffer;
  unsigned int MaxValueFrameBuffer2;
  int ReducedSize[2];

  vtkPolyData *ClippedBoundingBox;

  int LastSize[2];

  double ReductionFactor;

  // Supported extensions
  // List of unsupported required extensions. Pimpl.
  vtkUnsupportedRequiredExtensionsStringStream *UnsupportedRequiredExtensions;
  int LoadExtensionsSucceeded;

  int Supports_GL_ARB_texture_float;
  int SupportsPixelBufferObjects;

  vtkTimeStamp DataBufferTime;

  // Matrices used in internal computation. As a member variable,
  // only one memory allocation is performed.
  vtkMatrix4x4 *TempMatrix[3];

  double TableRange[2];

  // Final string to send to the GPU as the fragment program source code.
//  char *FragmentCode;
//  int FragmentCodeCapacity;

  int ErrorLine;
  int ErrorColumn;
  char *ErrorString;

  // Store the last projection an raycast method in order to not rebuild
  // the fragment code at every call.
  int LastParallelProjection;
  int LastRayCastMethod;
  int LastCroppingMode;
  int LastComponent;
  int LastShade;

  vtkImageData *SmallInput;
  vtkTimeStamp SmallInputBuildTime;

  void BuildScaleBiasProgram(vtkRenderWindow *w);

#if 0
  vtkIdType LoadedExtent[6];
  double LoadedBounds[6];
  vtkTimeStamp LoadedScalarTime;
  int LoadedCellFlag; // point data or cell data (or field data, not handled) ?
#endif

  unsigned int SavedFrameBuffer; // some offscreen mode use a framebuffer too.

  vtkTessellatedBoxSource *BoxSource;

  float *NoiseTexture;
  int NoiseTextureSize; // size of one dimension.
  unsigned int NoiseTextureId; // GLuint

  bool IgnoreSampleDistancePerPixel;

  vtkMapDataArrayTextureId *ScalarsTextures; // need a list for AMR mode.
  vtkMapMaskTextureId *MaskTextures; // need a list for AMR mode.

  vtkRGBTable *RGBTable;
  vtkRGBTable *Mask1RGBTable;
  vtkRGBTable *Mask2RGBTable;

  vtkOpacityTables *OpacityTables;

  vtkKWScalarField *CurrentScalar;
  vtkKWMask *CurrentMask;

  float ActualSampleDistance;

  double LastProgressEventTime; // initial value is 0.0. Expressed in seconds.

  bool PreserveOrientation;

  vtkShaderProgram2 *Program;
  vtkShader2 *Main;
  vtkShader2 *Projection;
  vtkShader2 *Trace;
  vtkShader2 *CroppingShader;
  vtkShader2 *Component;
  vtkShader2 *Shade;

  // Internal Variable used to keep track of whether or render window's size
  // changed and therefore we need re-allocation.
  bool        SizeChanged;

  vtkShaderProgram2 *ScaleBiasProgram;

private:
  vtkOpenGLGPUVolumeRayCastMapper(const vtkOpenGLGPUVolumeRayCastMapper&);  // Not implemented.
  void operator=(const vtkOpenGLGPUVolumeRayCastMapper&);  // Not implemented.
};

#endif