vtkPVRenderViewDataDeliveryManager.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkPVRenderViewDataDeliveryManager_h
#define vtkPVRenderViewDataDeliveryManager_h
 
#include "vtkBoundingBox.h" // needed for iVar.
#include "vtkPVDataDeliveryManager.h"
#include "vtkRemotingViewsModule.h" //needed for exports
#include "vtkSmartPointer.h"        // needed for iVar.
#include "vtkTuple.h"               // needed for vtkTuple.
#include "vtkWeakPointer.h"         // needed for iVar.
 
class vtkAlgorithmOutput;
class vtkDataObject;
class vtkExtentTranslator;
class vtkInformation;
class vtkMatrix4x4;
class vtkPVDataRepresentation;
class vtkPVView;
 
#include <vector> // for std::vector
 
class VTKREMOTINGVIEWS_EXPORT vtkPVRenderViewDataDeliveryManager : public vtkPVDataDeliveryManager
{
public:
  static vtkPVRenderViewDataDeliveryManager* New();
  vtkTypeMacro(vtkPVRenderViewDataDeliveryManager, vtkPVDataDeliveryManager);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void SetDeliverToAllProcesses(vtkPVDataRepresentation*, bool flag, bool low_res, int port = 0);
 
  void SetDeliverToClientAndRenderingProcesses(vtkPVDataRepresentation*, bool deliver_to_client,
    bool gather_before_delivery, bool low_res, int port = 0);
 
 
  void SetRedistributionMode(vtkPVDataRepresentation*, int mode, int port = 0);
  void SetRedistributionModeToSplitBoundaryCells(vtkPVDataRepresentation* repr, int port = 0);
  void SetRedistributionModeToDuplicateBoundaryCells(vtkPVDataRepresentation* repr, int port = 0);
  void SetRedistributionModeToUniquelyAssignBoundaryCells(
    vtkPVDataRepresentation* repr, int port = 0);
 
  void RedistributeDataForOrderedCompositing(bool use_lod);
 
  void ClearRedistributedData(bool use_load);
 
  void SetOrderedCompositingConfiguration(
    vtkPVDataRepresentation* repr, int config, const double* bds, int port = 0);
 
 
  void SetGeometryBounds(vtkPVDataRepresentation* repr, const double bds[6],
    vtkMatrix4x4* matrix = nullptr, int port = 0);
  vtkBoundingBox GetGeometryBounds(vtkPVDataRepresentation* repr, int port = 0);
  vtkBoundingBox GetTransformedGeometryBounds(vtkPVDataRepresentation* repr, int port = 0);
 
  // *******************************************************************
  // UNDER CONSTRUCTION STREAMING API
  // *******************************************************************
 
  void SetStreamable(vtkPVDataRepresentation*, bool, int port = 0);
 
 
  void SetNextStreamedPiece(vtkPVDataRepresentation* repr, vtkDataObject* piece, int port = 0);
  vtkDataObject* GetCurrentStreamedPiece(vtkPVDataRepresentation* repr, int port = 0);
  void ClearStreamedPieces();
 
  void DeliverStreamedPieces(unsigned int size, unsigned int* keys);
 
  bool GetRepresentationsReadyToStreamPieces(std::vector<unsigned int>& keys);
 
 
  vtkGetMacro(UseRedistributedDataAsDeliveredData, bool);
  vtkSetMacro(UseRedistributedDataAsDeliveredData, bool);
 
  int GetDeliveredDataKey(bool low_res) const override;
 
 
  const std::vector<vtkBoundingBox>& GetCuts() const { return this->Cuts; }
  vtkTimeStamp GetCutsMTime() const { return this->CutsMTime; }
 
 
  const std::vector<vtkBoundingBox>& GetRawCuts() const { return this->RawCuts; }
  const std::vector<int>& GetRawCutsRankAssignments() const { return this->RawCutsRankAssignments; }
 
protected:
  vtkPVRenderViewDataDeliveryManager();
  ~vtkPVRenderViewDataDeliveryManager() override;
 
  void MoveData(vtkPVDataRepresentation* repr, bool low_res, int port) override;
 
  int GetViewDataDistributionMode(bool low_res) const;
  int GetMoveMode(vtkInformation* info, int viewMode) const;
 
  std::vector<vtkBoundingBox> Cuts;
  std::vector<vtkBoundingBox> RawCuts;
  std::vector<int> RawCutsRankAssignments;
  vtkTimeStamp CutsMTime;
 
  vtkTimeStamp RedistributionTimeStamp;
  std::string LastCutsGeneratorToken;
  bool UseRedistributedDataAsDeliveredData = false;
 
private:
  vtkPVRenderViewDataDeliveryManager(const vtkPVRenderViewDataDeliveryManager&) = delete;
  void operator=(const vtkPVRenderViewDataDeliveryManager&) = delete;
};
 
#endif