VTK
vtkOpenGLGPUVolumeRayCastMapper.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkOpenGLGPUVolumeRayCastMapper.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
60 #ifndef vtkOpenGLGPUVolumeRayCastMapper_h
61 #define vtkOpenGLGPUVolumeRayCastMapper_h
62 #include <map> // For methods
63 
64 #include "vtkNew.h" // For vtkNew
65 #include "vtkRenderingVolumeOpenGL2Module.h" // For export macro
67 #include "vtkShader.h" // For methods
68 #include "vtkSmartPointer.h" // For smartptr
69 
70 
73 class vtkOpenGLCamera;
78 class vtkShaderProgram;
79 class vtkTextureObject;
80 class vtkVolume;
82 class vtkVolumeTexture;
83 
84 class VTKRENDERINGVOLUMEOPENGL2_EXPORT vtkOpenGLGPUVolumeRayCastMapper :
86 {
87 public:
89 
90  enum Passes
91  {
93  DepthPass = 1
94  };
95 
97  void PrintSelf( ostream& os, vtkIndent indent ) override;
98 
99  // Description:
100  // Low level API to enable access to depth texture in
101  // RenderToTexture mode. It will return either nullptr if
102  // RenderToImage was never turned on or texture captured
103  // the last time RenderToImage was on.
104  vtkTextureObject* GetDepthTexture();
105 
106  // Description:
107  // Low level API to enable access to color texture in
108  // RenderToTexture mode. It will return either nullptr if
109  // RenderToImage was never turned on or texture captured
110  // the last time RenderToImage was on.
111  vtkTextureObject* GetColorTexture();
112 
113  // Description:
114  // Low level API to export the depth texture as vtkImageData in
115  // RenderToImage mode.
116  void GetDepthImage(vtkImageData* im) override;
117 
118  // Description:
119  // Low level API to export the color texture as vtkImageData in
120  // RenderToImage mode.
121  void GetColorImage(vtkImageData* im) override;
122 
123  // Description:
124  // Mapper can have multiple passes and internally it will set
125  // the state. The state can not be set externally explicitly
126  // but can be set indirectly depending on the options set by
127  // the user.
128  vtkGetMacro(CurrentPass, int);
129 
130  // Sets a depth texture for this mapper to use
131  // This allows many mappers to use the same
132  // texture reducing GPU usage. If this is set
133  // the standard depth texture code is skipped
134  // The depth texture should be activated
135  // and deactivated outside of this class
136  void SetSharedDepthTexture(vtkTextureObject *nt);
137 
143  void SetPartitions(unsigned short x, unsigned short y, unsigned short z);
144 
153  bool PreLoadData(vtkRenderer* ren, vtkVolume* vol);
154 
156 
163  void AddShaderReplacement(
164  vtkShader::Type shaderType, // vertex, fragment, etc
165  const std::string& originalValue,
166  bool replaceFirst, // do this replacement before the default
167  const std::string& replacementValue,
168  bool replaceAll);
169  void ClearShaderReplacement(
170  vtkShader::Type shaderType, // vertex, fragment, etc
171  const std::string& originalValue,
172  bool replaceFirst);
173  void ClearAllShaderReplacements(vtkShader::Type shaderType);
174  void ClearAllShaderReplacements();
176 
178 
184  vtkSetStringMacro(VertexShaderCode);
185  vtkGetStringMacro(VertexShaderCode);
186  vtkSetStringMacro(FragmentShaderCode);
187  vtkGetStringMacro(FragmentShaderCode);
189 
190  // Description:
191  // Delete OpenGL objects.
192  // \post done: this->OpenGLObjectsCreated==0
193  void ReleaseGraphicsResources(vtkWindow *window) override;
194 
195 protected:
198 
200 
201  // Description:
202  // Build vertex and fragment shader for the volume rendering
203  void BuildDepthPassShader(vtkRenderer* ren, vtkVolume* vol,
204  int noOfComponents,
205  int independentComponents);
206 
207  // Description:
208  // Build vertex and fragment shader for the volume rendering
209  void BuildShader(vtkRenderer* ren);
210 
211  // TODO Take these out as these are no longer needed
212  // Methods called by the AMR Volume Mapper.
213  void PreRender(vtkRenderer * vtkNotUsed(ren),
214  vtkVolume *vtkNotUsed(vol),
215  double vtkNotUsed(datasetBounds)[6],
216  double vtkNotUsed(scalarRange)[2],
217  int vtkNotUsed(noOfComponents),
218  unsigned int vtkNotUsed(numberOfLevels)) override {};
219 
220  // \pre input is up-to-date
221  void RenderBlock(vtkRenderer *vtkNotUsed(ren),
222  vtkVolume *vtkNotUsed(vol),
223  unsigned int vtkNotUsed(level)) override {}
224 
225  void PostRender(vtkRenderer *vtkNotUsed(ren),
226  int vtkNotUsed(noOfComponents)) override {}
227 
228  // Description:
229  // Rendering volume on GPU
230  void GPURender(vtkRenderer *ren, vtkVolume *vol) override;
231 
232  // Description:
233  // Method that performs the actual rendering given a volume and a shader
234  void DoGPURender(vtkRenderer* ren,
235  vtkOpenGLCamera* cam,
236  vtkShaderProgram* shaderProgram);
237 
238  // Description:
239  // Update the reduction factor of the render viewport (this->ReductionFactor)
240  // according to the time spent in seconds to render the previous frame
241  // (this->TimeToDraw) and a time in seconds allocated to render the next
242  // frame (allocatedTime).
243  // \pre valid_current_reduction_range: this->ReductionFactor>0.0 && this->ReductionFactor<=1.0
244  // \pre positive_TimeToDraw: this->TimeToDraw>=0.0
245  // \pre positive_time: allocatedTime>0
246  // \post valid_new_reduction_range: this->ReductionFactor>0.0 && this->ReductionFactor<=1.0
247  void ComputeReductionFactor(double allocatedTime);
248 
249  // Description:
250  // Empty implementation.
251  void GetReductionRatio(double* ratio) override
252  {
253  ratio[0] = ratio[1] = ratio[2] = 1.0;
254  }
255 
256 
257  // Description:
258  // Empty implementation.
259  int IsRenderSupported(vtkRenderWindow *vtkNotUsed(window),
260  vtkVolumeProperty *vtkNotUsed(property)) override
261  {
262  return 1;
263  }
264 
266 
269  vtkMTimeType GetRenderPassStageMTime(vtkVolume* vol);
270 
274  void GetShaderTemplate(std::map<vtkShader::Type, vtkShader*>& shaders);
275 
279  void ReplaceShaderValues(std::map<vtkShader::Type, vtkShader*>& shaders,
280  vtkRenderer* ren, vtkVolume* vol, int numComps);
281 
286  void ReplaceShaderBase(std::map<vtkShader::Type, vtkShader*>& shaders,
287  vtkRenderer* ren, vtkVolume* vol, int numComps);
288  void ReplaceShaderTermination(std::map<vtkShader::Type, vtkShader*>& shaders,
289  vtkRenderer* ren, vtkVolume* vol, int numComps);
290  void ReplaceShaderShading(std::map<vtkShader::Type, vtkShader*>& shaders,
291  vtkRenderer* ren, vtkVolume* vol, int numComps);
292  void ReplaceShaderCompute(std::map<vtkShader::Type, vtkShader*>& shaders,
293  vtkRenderer* ren, vtkVolume* vol, int numComps);
294  void ReplaceShaderCropping(std::map<vtkShader::Type, vtkShader*>& shaders,
295  vtkRenderer* ren, vtkVolume* vol, int numComps);
296  void ReplaceShaderClipping(std::map<vtkShader::Type, vtkShader*>& shaders,
297  vtkRenderer* ren, vtkVolume* vol, int numComps);
298  void ReplaceShaderMasking(std::map<vtkShader::Type, vtkShader*>& shaders,
299  vtkRenderer* ren, vtkVolume* vol, int numComps);
300  void ReplaceShaderPicking(std::map<vtkShader::Type, vtkShader*>& shaders,
301  vtkRenderer* ren, vtkVolume* vol, int numComps);
302  void ReplaceShaderRTT(std::map<vtkShader::Type, vtkShader*>& shaders,
303  vtkRenderer* ren, vtkVolume* vol, int numComps);
304  void ReplaceShaderRenderPass(std::map<vtkShader::Type, vtkShader*>& shaders,
305  vtkVolume* vol, bool prePass);
306 
310  void SetShaderParametersRenderPass();
311 
319 
324  std::map<const vtkShader::ReplacementSpec, vtkShader::ReplacementValue>
326 
327 public:
329  using VolumeInputMap = std::map<int, vtkVolumeInputHelper>;
331 
332 private:
333  class vtkInternal;
334  vtkInternal* Impl;
335 
336  friend class vtkVolumeTexture;
337 
339  const vtkOpenGLGPUVolumeRayCastMapper&) = delete;
340  void operator=(const vtkOpenGLGPUVolumeRayCastMapper&) = delete;
341 };
342 
343 #endif // vtkOpenGLGPUVolumeRayCastMapper_h
vtkGPUVolumeRayCastMapper::New
static vtkGPUVolumeRayCastMapper * New()
vtkOpenGLGPUVolumeRayCastMapper::ResourceCallback
vtkGenericOpenGLResourceFreeCallback * ResourceCallback
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:199
vtkGPUVolumeRayCastMapper::GetDepthImage
virtual void GetDepthImage(vtkImageData *)
Low level API to export the depth texture as vtkImageData in RenderToImage mode.
Definition: vtkGPUVolumeRayCastMapper.h:327
vtkOpenGLVolumeGradientOpacityTables
Definition: vtkOpenGLVolumeGradientOpacityTable.h:216
vtkOpenGLVolumeRGBTables
Definition: vtkOpenGLVolumeRGBTable.h:215
vtkOpenGLGPUVolumeRayCastMapper::PostRender
void PostRender(vtkRenderer *vtkNotUsed(ren), int vtkNotUsed(noOfComponents)) override
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:225
vtkGPUVolumeRayCastMapper.h
vtkVolume
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:44
vtkShader.h
vtkOpenGLGPUVolumeRayCastMapper::PreRender
void PreRender(vtkRenderer *vtkNotUsed(ren), vtkVolume *vtkNotUsed(vol), double vtkNotUsed(datasetBounds)[6], double vtkNotUsed(scalarRange)[2], int vtkNotUsed(noOfComponents), unsigned int vtkNotUsed(numberOfLevels)) override
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:213
vtkOpenGLGPUVolumeRayCastMapper::LastRenderPassInfo
vtkNew< vtkInformation > LastRenderPassInfo
Caches the vtkOpenGLRenderPass::RenderPasses() information.
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:317
vtkOpenGLGPUVolumeRayCastMapper::FragmentShaderCode
char * FragmentShaderCode
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:323
vtkGPUVolumeRayCastMapper::ReleaseGraphicsResources
void ReleaseGraphicsResources(vtkWindow *) override
Release any graphics resources that are being consumed by this mapper.
Definition: vtkGPUVolumeRayCastMapper.h:355
vtkWindow
window superclass for vtkRenderWindow
Definition: vtkWindow.h:34
vtkOpenGLGPUVolumeRayCastMapper::RenderPass
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:92
vtkOpenGLGPUVolumeRayCastMapper::Passes
Passes
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:90
vtkImplicitFunction
abstract interface for implicit functions
Definition: vtkImplicitFunction.h:60
vtkX3D::level
Definition: vtkX3D.h:395
vtkShaderProgram
The ShaderProgram uses one or more Shader objects.
Definition: vtkShaderProgram.h:44
vtkGenericOpenGLResourceFreeCallback
Definition: vtkOpenGLResourceFreeCallback.h:25
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:39
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkTextureObject
abstracts an OpenGL texture object.
Definition: vtkTextureObject.h:41
vtkShader::Type
Type
Available shader types.
Definition: vtkShader.h:45
vtkOpenGLGPUVolumeRayCastMapper::IsRenderSupported
int IsRenderSupported(vtkRenderWindow *vtkNotUsed(window), vtkVolumeProperty *vtkNotUsed(property)) override
Based on hardware and properties, we may or may not be able to render using 3D texture mapping.
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:259
vtkGPUVolumeRayCastMapper::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkOpenGLGPUVolumeRayCastMapper::GetReductionRatio
void GetReductionRatio(double *ratio) override
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:251
vtkSmartPointer.h
vtkGPUVolumeRayCastMapper
Ray casting performed on the GPU.
Definition: vtkGPUVolumeRayCastMapper.h:43
vtkNew< vtkInformation >
vtkOpenGLGPUVolumeRayCastMapper::VertexShaderCode
char * VertexShaderCode
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:322
vtkGPUVolumeRayCastMapper::GetColorImage
virtual void GetColorImage(vtkImageData *)
Low level API to export the color texture as vtkImageData in RenderToImage mode.
Definition: vtkGPUVolumeRayCastMapper.h:335
vtkOpenGLGPUVolumeRayCastMapper::RenderBlock
void RenderBlock(vtkRenderer *vtkNotUsed(ren), vtkVolume *vtkNotUsed(vol), unsigned int vtkNotUsed(level)) override
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:221
vtkOpenGLCamera
OpenGL camera.
Definition: vtkOpenGLCamera.h:32
vtkVolumeTexture
Creates and manages the volume texture rendered by vtkOpenGLGPUVolumeRayCastMapper.
Definition: vtkVolumeTexture.h:87
vtkOpenGLGPUVolumeRayCastMapper
OpenGL implementation of volume rendering through ray-casting.
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:84
vtkX3D::string
Definition: vtkX3D.h:490
vtkOpenGLGPUVolumeRayCastMapper::CurrentPass
int CurrentPass
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:321
vtkNew.h
vtkVolumeInputHelper
Convenience container for internal structures specific to a volume input.
Definition: vtkVolumeInputHelper.h:49
vtkRenderer
abstract specification for renderers
Definition: vtkRenderer.h:57
vtkGPUVolumeRayCastMapper::GPURender
virtual void GPURender(vtkRenderer *, vtkVolume *)
Handled in the subclass - the actual render method.
Definition: vtkGPUVolumeRayCastMapper.h:347
vtkOpenGLVolumeOpacityTables
Definition: vtkOpenGLVolumeOpacityTable.h:263
vtkOpenGLGPUVolumeRayCastMapper::AssembledInputs
VolumeInputMap AssembledInputs
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:330
vtkOpenGLGPUVolumeRayCastMapper::VolumeInputMap
std::map< int, vtkVolumeInputHelper > VolumeInputMap
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:329
vtkOpenGLGPUVolumeRayCastMapper::ReductionFactor
double ReductionFactor
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:320
vtkRenderWindow
create a window for renderers to draw into
Definition: vtkRenderWindow.h:81
vtkOpenGLTransferFunctions2D
Container for a set of TransferFunction2D instances.
Definition: vtkOpenGLTransferFunction2D.h:214
vtkOpenGLGPUVolumeRayCastMapper::UserShaderReplacements
std::map< const vtkShader::ReplacementSpec, vtkShader::ReplacementValue > UserShaderReplacements
Definition: vtkOpenGLGPUVolumeRayCastMapper.h:325
vtkVolumeProperty
represents the common properties for rendering a volume.
Definition: vtkVolumeProperty.h:68
vtkMTimeType
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:302