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
#include "vtkWrappingHints.h"         // For VTK_MARSHALAUTO

VTK_ABI_NAMESPACE_BEGIN

class VTKRENDERINGWEBGPU_EXPORT VTK_MARSHALAUTO 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