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 
131 
137  void SetNoiseGenerator(vtkImplicitFunction* generator);
138  vtkSetVector2Macro(NoiseTextureSize, int);
140 
146  void SetPartitions(unsigned short x, unsigned short y, unsigned short z);
147 
156  bool PreLoadData(vtkRenderer* ren, vtkVolume* vol);
157 
159 
166  void AddShaderReplacement(
167  vtkShader::Type shaderType, // vertex, fragment, etc
168  const std::string& originalValue,
169  bool replaceFirst, // do this replacement before the default
170  const std::string& replacementValue,
171  bool replaceAll);
172  void ClearShaderReplacement(
173  vtkShader::Type shaderType, // vertex, fragment, etc
174  const std::string& originalValue,
175  bool replaceFirst);
176  void ClearAllShaderReplacements(vtkShader::Type shaderType);
177  void ClearAllShaderReplacements();
179 
181 
187  vtkSetStringMacro(VertexShaderCode);
188  vtkGetStringMacro(VertexShaderCode);
189  vtkSetStringMacro(FragmentShaderCode);
190  vtkGetStringMacro(FragmentShaderCode);
192 
193 protected:
196 
197  // Description:
198  // Delete OpenGL objects.
199  // \post done: this->OpenGLObjectsCreated==0
200  void ReleaseGraphicsResources(vtkWindow *window) override;
202 
203  // Description:
204  // Build vertex and fragment shader for the volume rendering
205  void BuildDepthPassShader(vtkRenderer* ren, vtkVolume* vol,
206  int noOfComponents,
207  int independentComponents);
208 
209  // Description:
210  // Build vertex and fragment shader for the volume rendering
211  void BuildShader(vtkRenderer* ren);
212 
213  // TODO Take these out as these are no longer needed
214  // Methods called by the AMR Volume Mapper.
215  void PreRender(vtkRenderer * vtkNotUsed(ren),
216  vtkVolume *vtkNotUsed(vol),
217  double vtkNotUsed(datasetBounds)[6],
218  double vtkNotUsed(scalarRange)[2],
219  int vtkNotUsed(noOfComponents),
220  unsigned int vtkNotUsed(numberOfLevels)) override {};
221 
222  // \pre input is up-to-date
223  void RenderBlock(vtkRenderer *vtkNotUsed(ren),
224  vtkVolume *vtkNotUsed(vol),
225  unsigned int vtkNotUsed(level)) override {}
226 
227  void PostRender(vtkRenderer *vtkNotUsed(ren),
228  int vtkNotUsed(noOfComponents)) override {}
229 
230  // Description:
231  // Rendering volume on GPU
232  void GPURender(vtkRenderer *ren, vtkVolume *vol) override;
233 
234  // Description:
235  // Method that performs the actual rendering given a volume and a shader
236  void DoGPURender(vtkRenderer* ren,
237  vtkOpenGLCamera* cam,
238  vtkShaderProgram* shaderProgram);
239 
240  // Description:
241  // Update the reduction factor of the render viewport (this->ReductionFactor)
242  // according to the time spent in seconds to render the previous frame
243  // (this->TimeToDraw) and a time in seconds allocated to render the next
244  // frame (allocatedTime).
245  // \pre valid_current_reduction_range: this->ReductionFactor>0.0 && this->ReductionFactor<=1.0
246  // \pre positive_TimeToDraw: this->TimeToDraw>=0.0
247  // \pre positive_time: allocatedTime>0
248  // \post valid_new_reduction_range: this->ReductionFactor>0.0 && this->ReductionFactor<=1.0
249  void ComputeReductionFactor(double allocatedTime);
250 
251  // Description:
252  // Empty implementation.
253  void GetReductionRatio(double* ratio) override
254  {
255  ratio[0] = ratio[1] = ratio[2] = 1.0;
256  }
257 
258 
259  // Description:
260  // Empty implementation.
261  int IsRenderSupported(vtkRenderWindow *vtkNotUsed(window),
262  vtkVolumeProperty *vtkNotUsed(property)) override
263  {
264  return 1;
265  }
266 
268 
271  vtkMTimeType GetRenderPassStageMTime(vtkVolume* vol);
272 
276  void GetShaderTemplate(std::map<vtkShader::Type, vtkShader*>& shaders);
277 
281  void ReplaceShaderValues(std::map<vtkShader::Type, vtkShader*>& shaders,
282  vtkRenderer* ren, vtkVolume* vol, int numComps);
283 
288  void ReplaceShaderBase(std::map<vtkShader::Type, vtkShader*>& shaders,
289  vtkRenderer* ren, vtkVolume* vol, int numComps);
290  void ReplaceShaderTermination(std::map<vtkShader::Type, vtkShader*>& shaders,
291  vtkRenderer* ren, vtkVolume* vol, int numComps);
292  void ReplaceShaderShading(std::map<vtkShader::Type, vtkShader*>& shaders,
293  vtkRenderer* ren, vtkVolume* vol, int numComps);
294  void ReplaceShaderCompute(std::map<vtkShader::Type, vtkShader*>& shaders,
295  vtkRenderer* ren, vtkVolume* vol, int numComps);
296  void ReplaceShaderCropping(std::map<vtkShader::Type, vtkShader*>& shaders,
297  vtkRenderer* ren, vtkVolume* vol, int numComps);
298  void ReplaceShaderClipping(std::map<vtkShader::Type, vtkShader*>& shaders,
299  vtkRenderer* ren, vtkVolume* vol, int numComps);
300  void ReplaceShaderMasking(std::map<vtkShader::Type, vtkShader*>& shaders,
301  vtkRenderer* ren, vtkVolume* vol, int numComps);
302  void ReplaceShaderPicking(std::map<vtkShader::Type, vtkShader*>& shaders,
303  vtkRenderer* ren, vtkVolume* vol, int numComps);
304  void ReplaceShaderRTT(std::map<vtkShader::Type, vtkShader*>& shaders,
305  vtkRenderer* ren, vtkVolume* vol, int numComps);
306  void ReplaceShaderRenderPass(std::map<vtkShader::Type, vtkShader*>& shaders,
307  vtkVolume* vol, bool prePass);
308 
312  void SetShaderParametersRenderPass();
313 
321 
326  std::map<const vtkShader::ReplacementSpec, vtkShader::ReplacementValue>
328 
329 public:
331  using VolumeInputMap = std::map<int, vtkVolumeInputHelper>;
333 
334 private:
335  class vtkInternal;
336  vtkInternal* Impl;
337 
338  friend class vtkVolumeTexture;
339 
340  vtkImplicitFunction* NoiseGenerator;
341  int NoiseTextureSize[2];
342 
344  const vtkOpenGLGPUVolumeRayCastMapper&) = delete;
345  void operator=(const vtkOpenGLGPUVolumeRayCastMapper&) = delete;
346 };
347 
348 #endif // vtkOpenGLGPUVolumeRayCastMapper_h
abstract interface for implicit functions
virtual void GPURender(vtkRenderer *, vtkVolume *)
Handled in the subclass - the actual render method.
void ReleaseGraphicsResources(vtkWindow *) override
Release any graphics resources that are being consumed by this mapper.
represents a volume (data & properties) in a rendered scene
Definition: vtkVolume.h:44
std::map< const vtkShader::ReplacementSpec, vtkShader::ReplacementValue > UserShaderReplacements
Container for a set of TransferFunction2D instances.
vtkGenericOpenGLResourceFreeCallback * ResourceCallback
vtkTypeUInt32 vtkMTimeType
Definition: vtkType.h:300
Creates and manages the volume texture rendered by vtkOpenGLGPUVolumeRayCastMapper.
std::map< int, vtkVolumeInputHelper > VolumeInputMap
virtual void GetDepthImage(vtkImageData *)
Low level API to export the depth texture as vtkImageData in RenderToImage mode.
Type
Available shader types.
Definition: vtkShader.h:45
Convenience container for internal structures specific to a volume input.
virtual void GetColorImage(vtkImageData *)
Low level API to export the color texture as vtkImageData in RenderToImage mode.
void PreRender(vtkRenderer *vtkNotUsed(ren), vtkVolume *vtkNotUsed(vol), double vtkNotUsed(datasetBounds)[6], double vtkNotUsed(scalarRange)[2], int vtkNotUsed(noOfComponents), unsigned int vtkNotUsed(numberOfLevels)) override
abstract specification for renderers
Definition: vtkRenderer.h:57
window superclass for vtkRenderWindow
Definition: vtkWindow.h:34
OpenGL implementation of volume rendering through ray-casting.
a simple class to control print indentation
Definition: vtkIndent.h:33
topologically and geometrically regular array of data
Definition: vtkImageData.h:39
void RenderBlock(vtkRenderer *vtkNotUsed(ren), vtkVolume *vtkNotUsed(vol), unsigned int vtkNotUsed(level)) override
void PostRender(vtkRenderer *vtkNotUsed(ren), int vtkNotUsed(noOfComponents)) override
represents the common properties for rendering a volume.
abstracts an OpenGL texture object.
create a window for renderers to draw into
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.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
OpenGL camera.
void GetReductionRatio(double *ratio) override
Ray casting performed on the GPU.
static vtkGPUVolumeRayCastMapper * New()
vtkNew< vtkInformation > LastRenderPassInfo
Caches the vtkOpenGLRenderPass::RenderPasses() information.
The ShaderProgram uses one or more Shader objects.