vtkWebGPUComputeFrustumCuller.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkWebGPUComputeFrustumCuller_h
#define vtkWebGPUComputeFrustumCuller_h
 
#include "vtkCuller.h"
#include "vtkNew.h"                   // for new macro
#include "vtkRenderingWebGPUModule.h" // For export macro
#include "vtkSmartPointer.h"          // for the pipeline smart pointer
#include "vtkWebGPUComputePipeline.h" // for the member compute pipeline
#include "vtkWrappingHints.h"         // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
 
class VTKRENDERINGWEBGPU_EXPORT VTK_MARSHALAUTO vtkWebGPUComputeFrustumCuller : public vtkCuller
{
public:
  vtkTypeMacro(vtkWebGPUComputeFrustumCuller, vtkCuller);
  static vtkWebGPUComputeFrustumCuller* New();
 
  virtual double Cull(
    vtkRenderer* renderer, vtkProp** propList, int& listLength, int& initialized) override;
 
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
protected:
  vtkWebGPUComputeFrustumCuller();
  ~vtkWebGPUComputeFrustumCuller() override;
 
private:
  vtkWebGPUComputeFrustumCuller(const vtkWebGPUComputeFrustumCuller&) = delete;
  void operator=(const vtkWebGPUComputeFrustumCuller&) = delete;
 
  void CreateInputBoundsBuffer(vtkProp** propList, unsigned int nbProps);
 
  void CreateOutputIndicesBuffer(int nbProps);
 
  void CreateViewProjMatrixBuffer(const std::vector<float>& matrixData);
 
  void ResizeCuller(vtkProp** propList, int propsCount);
 
  void ResizeBoundsBuffer(vtkProp** propList, int newPropsCount);
 
  void ResizeOutputIndicesBuffer(int newPropsCount);
 
  void ResizeScratchList(vtkProp** propList, int listLength);
 
  void TriggerBoundsRecomputation(vtkProp** propList, int listLength);
 
  void UpdateBoundsBuffer(vtkProp** propList, int listLength);
 
  void UpdateCamera(vtkRenderer* renderer);
 
  static void OutputObjectCountMapCallback(const void* mappedData, void* userdata);
 
  static void OutputObjectIndicesMapCallback(const void* mappedData, void* userdata);
 
  struct OutputIndicesCallbackData
  {
    // The list of props. This should be the same list as passed in parameter to the Cull() method
    vtkProp** propList = nullptr;
    // How many props passed the culling test? This should be the value contained in the OutputCount
    // WebGPU buffer
    int* indicesCount = nullptr;
 
    // The scratch list is a pointer on the pre-allocated vector stored in this compute culler
    std::vector<vtkProp*>* scratchList = nullptr;
  };
 
  // How many props was the culler last configured for. This variable is used to determine if the
  // number of props to be culled has changed since last time, meaning that we have to recreate a
  // new bounds buffer, a new PropsBounds cache std::vector etc...
  int PreviousPropsCount = -1;
 
  // Compute pipeline used for the frustum culling compute shader
  vtkSmartPointer<vtkWebGPUComputePipeline> Pipeline;
 
  // Frustum culling compute shader pass
  vtkSmartPointer<vtkWebGPUComputePass> FrustumCullingPass;
 
  // Scratch list used by the OutputObjectIndicesMapCallback
  std::vector<vtkProp*> CallbackScratchList;
 
  // Index of the input bounds buffer in the compute pipeline
  int InputBoundsBufferIndex = -1;
  // Index of the buffer that contains the view-projection matrix of the camera
  int CameraViewProjMatrixBufferIndex = -1;
  // Buffer that will contain the indices of the objects that were not culled.
  // This buffer will need to be initialized when the cull method is called because we don't know
  // how many actor we're going to cull yet (and thus we cannot initialize the size of this buffer)
  int OutputIndicesBufferIndex = -1;
  // Index of the buffer that contains the number of actors that were not culled
  int OutputObjectCountBufferIndex = -1;
};
 
VTK_ABI_NAMESPACE_END
 
#endif