vtkWebGPUComputeOcclusionCuller.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 vtkWebGPUComputeOcclusionCuller_h
#define vtkWebGPUComputeOcclusionCuller_h
 
#include "vtkCallbackCommand.h" // for the bounds recomputed callback
#include "vtkCuller.h"
#include "vtkNew.h"                   // for new macro
#include "vtkRenderingWebGPUModule.h" // For export macro
#include "vtkSmartPointer.h"          // for the pipeline smart pointer
#include "vtkWebGPUComputePass.h"     // for compute passes
#include "vtkWebGPUComputePipeline.h" // for the member compute pipeline
#include "vtkWebGPURenderWindow.h"    // for the render window weak pointer member
 
VTK_ABI_NAMESPACE_BEGIN
 
class VTKRENDERINGWEBGPU_EXPORT vtkWebGPUComputeOcclusionCuller : public vtkCuller
{
public:
  vtkTypeMacro(vtkWebGPUComputeOcclusionCuller, vtkCuller);
  static vtkWebGPUComputeOcclusionCuller* New();
 
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void SetRenderWindow(vtkWebGPURenderWindow* webGpuRenderWindow);
 
  double Cull(
    vtkRenderer* renderer, vtkProp** propList, int& listLength, int& initialized) override;
 
protected:
  vtkWebGPUComputeOcclusionCuller();
  ~vtkWebGPUComputeOcclusionCuller() override;
 
private:
  vtkWebGPUComputeOcclusionCuller(const vtkWebGPUComputeOcclusionCuller&) = delete;
  void operator=(const vtkWebGPUComputeOcclusionCuller&) = delete;
  void SetupDepthBufferCopyPass();
 
  void SetupMipmapsPass();
 
  void SetupCullingPass();
 
  void FirstPassRender(vtkRenderer* renderer, vtkProp** propList, int listLength);
 
  void CopyDepthBuffer();
 
  void DepthMipmaps();
 
  void PropCulling(vtkRenderer* renderer, vtkProp** propList, int& listLength);
 
  void UpdateCameraMVPBuffer(vtkRenderer* renderer);
 
  void UpdateBoundsBuffers(vtkProp** propList, int listLength);
 
  void AddOcclusionCullingPipelineToRenderer(vtkRenderer* renderer);
 
  void CreateHierarchicalZBuffer();
 
  int ComputeMipLevelsSizes(int width, int height);
 
  void ResizeHierarchicalZBuffer(uint32_t newWidth, uint32_t newHeight);
 
  void ResizeHierarchicalZBufferMipmapsChain();
 
  void FinishSetupDepthCopyPass();
 
  void FinishSetupMipmapsPass();
 
  void FinishSetupCullingPass();
 
  static void ReadIndicesCountCallback(const void* mappedData, void* indicesCount);
 
  static void FillObjectsToDrawCallback(const void* mappedData, void* data);
 
  static void OutputIndicesCulledCallback(const void* mappedData, void* data);
 
  static void WindowResizedCallback(
    vtkObject* caller, unsigned long eid, void* clientdata, void* calldata);
 
  // Occlusion culling pipeline
  vtkSmartPointer<vtkWebGPUComputePipeline> OcclusionCullingPipeline;
 
  // Pass that copies the depth buffer of the render window into the mip level 0 of the hierarchical
  // z-buffer
  vtkSmartPointer<vtkWebGPUComputePass> DepthBufferCopyPass;
 
  // Index of the hierarchical z buffer in the depth buffer copy compute pass
  int HierarchicalZBufferTextureIndexCopyPass = -1;
  // Index of the hierarchical z buffer in the depth buffer mipmaps pass
  int HierarchicalZBufferTextureIndexMipmapsPass = -1;
  // Index of the hierarchical z buffer in the culling pass
  int HierarchicalZBufferTextureIndexCullingPass = -1;
  // All the views necessary for the computation of the depth buffer mipmaps
  std::vector<vtkSmartPointer<vtkWebGPUComputeTextureView>> HierarchicalZBufferMipmapViews;
  // Texture view indices within the DepthMipmapsPass compute pass
  std::vector<int> HierarchicalZBufferMipmapViewsIndices;
  // Total number of mipmaps of the hierarchical z buffer
  int HierarchicalZBufferMipmapCount = -1;
  // Widths of the successive mipmaps of the hierarchical z buffer
  std::vector<int> MipmapWidths;
  // Heights of the successive mipmaps of the hierarchical z buffer
  std::vector<int> MipmapHeights;
  // We need to keep the uniform buffer here because we can only create it once the RenderWindow has
  // set its Device to the pipeline of this occlusion culler. We will add the buffer to the pipeline
  // on the first frame, when we're sure that the Device has been set
 
  // Pass that downsamples the mipmap level 0 of the depth buffer into as many mipmap levels as
  // possible
  vtkSmartPointer<vtkWebGPUComputePass> DepthMipmapsPass;
  // Pass that does the culling of the actors against the hierarchial z-buffer
  vtkSmartPointer<vtkWebGPUComputePass> CullingPass;
 
  // Index of the hierarchical z buffer texture view in the culling pass
  int CullingPassHierarchicalZBufferView = -1;
  // Index of the bounds buffer in the culling pass
  int CullingPassBoundsBufferIndex = -1;
  // Index of the buffer that contains the indices of the props that passed the culling test in the
  // culling pass
  int CullingPassOutputIndicesBufferIndex = -1;
  // How many props that were sent to the culling shader passed the culling test
  int CullingPassOutputIndicesCountBufferIndex = -1;
  // Index of the buffer that contains the indices of the props that were culled. Needed to update
  // the visibility of the props in the PropsRendered array of the WGPURenderer
  int CullingPassOutputIndicesCulledBufferIndex = -1;
  // How many props were culled by the culling pass
  int CullingPassOutputIndicesCulledCountBufferIndex = -1;
  // Index of the buffer that contains the number of bounds to cull in the culling pass
  int CullingPassBoundsCountBufferIndex = -1;
  // Index of the buffer that contains the view projection matrix in the culling pass
  int CullingPassMVPMatrixBufferIndex = -1;
 
  // Structure passed to the callbacks for reading the results of the culling pass
  struct FillObjectsToDrawCallbackMapData
  {
    // How many props passed the culling test.
    // This is a pointer to the 'listLength' parameter of the Cull() method
    int* listLength = nullptr;
    // Prop list of the renderer that needs to be updated
    vtkProp** propList = nullptr;
 
    // WebGPU renderer
    // Used for accessing the 'rendered last frame' list
    vtkWebGPURenderer* renderer = nullptr;
  };
 
  // Structure passed to the callbacks for reading the results of the culling pass
  struct OutputIndicesCulledMapData
  {
    // Point to the renderer for removing the props that were culled from the list of "props
    // rendered last frame"
    vtkWebGPURenderer* renderer = nullptr;
 
    // Prop list of the renderer
    vtkProp** propList = nullptr;
 
    // How many props were culled
    int culledCount = -1;
  };
 
  // If this is the first frame, every object is going to be rendered b the FirstPassRender to fill
  // the z-buffer
  bool FirstFrame = true;
  // Whether or not we're done initializing the compute passes of this culler
  bool Initialized = false;
  // Render window whose depth buffer we're going to use for the culling
  vtkWeakPointer<vtkWebGPURenderWindow> WebGPURenderWindow = nullptr;
 
  // Callback command for when the render window that this occlusion culler is attached to is
  // resized
  vtkSmartPointer<vtkCallbackCommand> WindowResizedCallbackCommand;
};
 
VTK_ABI_NAMESPACE_END
 
#endif