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