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