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