vtkIceTCompositePass.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkIceTCompositePass_h
#define vtkIceTCompositePass_h
 
#include "vtkNew.h"                 // needed for vtkWeakPointer.
#include "vtkRemotingViewsModule.h" // needed for export macro
#include "vtkRenderPass.h"
#include "vtkSynchronizedRenderers.h" //  needed for vtkRawImage.
#include <memory>                     // for std::unique_pt
 
class vtkFloatArray;
class vtkIceTContext;
class vtkMatrix4x4;
class vtkMultiProcessController;
class vtkOpenGLHelper;
class vtkOpenGLRenderWindow;
class vtkOrderedCompositingHelper;
class vtkPixelBufferObject;
class vtkTextureObject;
class vtkUnsignedCharArray;
 
class VTKREMOTINGVIEWS_EXPORT vtkIceTCompositePass : public vtkRenderPass
{
public:
  static vtkIceTCompositePass* New();
  vtkTypeMacro(vtkIceTCompositePass, vtkRenderPass);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Render(const vtkRenderState* s) override;
 
  void ReleaseGraphicsResources(vtkWindow* w) override;
 
 
  vtkGetObjectMacro(Controller, vtkMultiProcessController);
  virtual void SetController(vtkMultiProcessController* controller);
 
 
  void SetRenderPass(vtkRenderPass*);
  vtkGetObjectMacro(RenderPass, vtkRenderPass);
 
 
  vtkSetVector2Macro(TileDimensions, int);
  vtkGetVector2Macro(TileDimensions, int);
 
 
  vtkSetVector2Macro(TileMullions, int);
  vtkGetVector2Macro(TileMullions, int);
 
 
  vtkSetMacro(DataReplicatedOnAllProcesses, bool);
  vtkGetMacro(DataReplicatedOnAllProcesses, bool);
  vtkBooleanMacro(DataReplicatedOnAllProcesses, bool);
 
 
  vtkSetClampMacro(ImageReductionFactor, int, 1, 50);
  vtkGetMacro(ImageReductionFactor, int);
 
 
  vtkGetObjectMacro(OrderedCompositingHelper, vtkOrderedCompositingHelper);
  virtual void SetOrderedCompositingHelper(vtkOrderedCompositingHelper* helper);
 
 
  vtkGetMacro(RenderEmptyImages, bool);
  vtkSetMacro(RenderEmptyImages, bool);
  vtkBooleanMacro(RenderEmptyImages, bool);
 
 
  vtkGetMacro(UseOrderedCompositing, bool);
  vtkSetMacro(UseOrderedCompositing, bool);
  vtkBooleanMacro(UseOrderedCompositing, bool);
 
  void GetLastRenderedTile(vtkSynchronizedRenderers::vtkRawImage& tile);
 
  vtkFloatArray* GetLastRenderedDepths();
 
 
  vtkSetMacro(EnableFloatValuePass, bool);
 
  vtkFloatArray* GetLastRenderedRGBA32F();
 
  void PushIceTDepthBufferToScreen(const vtkRenderState* render_state);
 
 
  vtkSetMacro(DisplayRGBAResults, bool);
  vtkGetMacro(DisplayRGBAResults, bool);
  vtkSetMacro(DisplayDepthResults, bool);
  vtkGetMacro(DisplayDepthResults, bool);
 
 
  struct IceTDrawParams;
  void Draw(const vtkRenderState* render_state, const IceTDrawParams&);
 
protected:
  vtkIceTCompositePass();
  ~vtkIceTCompositePass() override;
 
 
  virtual void SetupContext(const vtkRenderState*);
  virtual void CleanupContext(const vtkRenderState*);
 
  void ReadyProgram(vtkOpenGLRenderWindow* context);
 
  void UpdateTileInformation(const vtkRenderState*);
 
  void DisplayResultsIfNeeded(const vtkRenderState*);
 
  void UpdateMatrices(const vtkRenderState*, double aspect);
 
  vtkMultiProcessController* Controller;
  vtkOrderedCompositingHelper* OrderedCompositingHelper;
  vtkRenderPass* RenderPass;
  vtkIceTContext* IceTContext;
 
  bool RenderEmptyImages;
  bool UseOrderedCompositing;
  bool DataReplicatedOnAllProcesses;
  bool EnableFloatValuePass;
  int TileDimensions[2];
  int TileMullions[2];
 
  int ImageReductionFactor;
 
  bool DisplayRGBAResults;
  bool DisplayDepthResults;
 
  vtkNew<vtkFloatArray> LastRenderedDepths;
 
  vtkNew<vtkFloatArray> LastRenderedRGBA32F;
 
  vtkPixelBufferObject* PBO;
  vtkTextureObject* ZTexture;
  vtkOpenGLHelper* Program;
 
  std::unique_ptr<vtkSynchronizedRenderers::vtkRawImage> LastRenderedRGBAColors;
 
private:
  vtkIceTCompositePass(const vtkIceTCompositePass&) = delete;
  void operator=(const vtkIceTCompositePass&) = delete;
 
  vtkNew<vtkMatrix4x4> ModelView;
  vtkNew<vtkMatrix4x4> Projection;
  vtkNew<vtkMatrix4x4> IceTProjection;
};
 
#endif