DepthAndShadowPass.h

Go to the documentation of this file.

#pragma once
 
#include "Core.h"
#include "Tags.h"
#include "Texture.h"
#include "Camera.h"
#include "math_types.h"
#include "LightUniforms.h"
 
#include <SDL3/SDL_gpu.h>
#include <span>
 
namespace candlewick {

class DepthPass {
  SDL_GPUDevice *_device = nullptr;
 
public:
  static constexpr Uint32 TRANSFORM_SLOT = 0;
  struct Config {
    SDL_GPUCullMode cull_mode;
    float depth_bias_constant_factor;
    float depth_bias_slope_factor;
    bool enable_depth_bias;
    bool enable_depth_clip;
  };
 
  SDL_GPUTexture *depthTexture = nullptr;
  SDL_GPUGraphicsPipeline *pipeline = nullptr;
 
  DepthPass(NoInitT) {}

  DepthPass(const Device &device, const MeshLayout &layout,
            SDL_GPUTexture *depth_texture, SDL_GPUTextureFormat format,
            const Config &config = {});

  DepthPass(const Device &device, const MeshLayout &layout,
            const Texture &depth_texture, const Config &config = {});
 
  DepthPass(const DepthPass &) = delete;
  DepthPass &operator=(const DepthPass &) = delete;
  DepthPass(DepthPass &&other) noexcept;
  DepthPass &operator=(DepthPass &&other) noexcept;
 
  void render(CommandBuffer &cmdBuf, const Mat4f &viewProj,
              std::span<const OpaqueCastable> castables);

  void release() noexcept;
  ~DepthPass() noexcept { this->release(); }
};

class ShadowMapPass {
  SDL_GPUDevice *_device = nullptr;
  DepthPass _depthPass{NoInit};
 
public:
  struct Config {
    // default is 2k x 2k texture
    Uint32 width = 2048;
    Uint32 height = 2048;
    DepthPass::Config depthPassConfig{
        .cull_mode = SDL_GPU_CULLMODE_NONE,
        .depth_bias_constant_factor = 0.f,
        .depth_bias_slope_factor = 0.f,
        .enable_depth_bias = false,
        .enable_depth_clip = false,
    };
  };
  Texture shadowMap{NoInit};
  SDL_GPUSampler *sampler = nullptr;
  Camera cam;
 
  ShadowMapPass(NoInitT) {}
 
  ShadowMapPass(const Device &device, const MeshLayout &layout,
                SDL_GPUTextureFormat format, const Config &config);
 
  ShadowMapPass(const Device &device, const MeshLayout &layout,
                SDL_GPUTextureFormat format)
      : ShadowMapPass(device, layout, format, {}) {}
 
  ShadowMapPass(const ShadowMapPass &) = delete;
  ShadowMapPass &operator=(const ShadowMapPass &) = delete;
  ShadowMapPass(ShadowMapPass &&other) noexcept;
  ShadowMapPass &operator=(ShadowMapPass &&other) noexcept;
 
  void render(CommandBuffer &cmdBuf, const Mat4f &viewProj,
              std::span<const OpaqueCastable> castables);
 
  void release() noexcept;
  ~ShadowMapPass() noexcept { this->release(); }
};
 
using ShadowPassConfig = ShadowMapPass::Config;

 
inline void ShadowMapPass::render(CommandBuffer &cmdBuf, const Mat4f &viewProj,
                                  std::span<const OpaqueCastable> castables) {
  _depthPass.render(cmdBuf, viewProj, castables);
}

void renderShadowPassFromAABB(CommandBuffer &cmdBuf, ShadowMapPass &passInfo,
                              const DirectionalLight &dirLight,
                              std::span<const OpaqueCastable> castables,
                              const AABB &worldSceneBounds);

void renderShadowPassFromFrustum(CommandBuffer &cmdBuf, ShadowMapPass &passInfo,
                                 const DirectionalLight &dirLight,
                                 std::span<const OpaqueCastable> castables,
                                 const FrustumCornersType &worldSpaceCorners);

inline Mat4f shadowOrthographicMatrix(const Float2 &sizes, float zMin,
                                      float zMax) {
  const float sx = 2.f / sizes.x();
  const float sy = 2.f / sizes.y();
  const float sz = 1.f / (zMin - zMax);
  const float pz = 0.5f * (zMin + zMax) * sz;
 
  Mat4f proj = Mat4f::Zero();
  proj(0, 0) = sx;
  proj(1, 1) = sy;
  proj(2, 2) = sz;
  proj(2, 3) = -pz;
  proj(3, 3) = 1.f;
  return proj;
}

 
} // namespace candlewick