vtkIceTCompositePass.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ParaView
  Module:    $RCSfile$

  Copyright (c) Kitware, Inc.
  All rights reserved.
  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html 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 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 vtkMultiProcessController;
class vtkPartitionOrderingInterface;
class vtkIceTContext;
class vtkPixelBufferObject;
class vtkTextureObject;
class vtkOpenGLRenderWindow;
class vtkUnsignedCharArray;
class vtkFloatArray;
class vtkOpenGLHelper;
class vtkMatrix4x4;

class VTKREMOTINGVIEWS_EXPORT vtkIceTCompositePass : public vtkRenderPass
{
public:
  static vtkIceTCompositePass* New();
  vtkTypeMacro(vtkIceTCompositePass, vtkRenderPass);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual 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(PartitionOrdering, vtkPartitionOrderingInterface);
  virtual void SetPartitionOrdering(vtkPartitionOrderingInterface* partitionOrdering);


  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;
  vtkPartitionOrderingInterface* PartitionOrdering;
  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