DepthAndShadowPass.h

Go to the documentation of this file.

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

using OpaqueCastable = std::tuple<const Mesh &, Mat4f>;

static constexpr size_t kNumLights = 4;

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;
    const char *pipeline_name;
    SDL_GPUSampleCount sample_count;
  };
 
  SDL_GPUTexture *depthTexture = nullptr;
  GraphicsPipeline pipeline{NoInit};
 
  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 &texture, const Config &config = {})
      : DepthPass(device, layout, texture, texture.format(), 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(); }
};

struct ShadowPassConfig {
  // default is 2k x 2k texture
  Uint32 width = 2048;
  Uint32 height = 2048;
  float depth_bias_constant_factor = 0.f;
  float depth_bias_slope_factor = 0.f;
  bool enable_depth_bias = false;
  bool enable_depth_clip = false;
  Uint32 numLights = 2;
};

class ShadowMapPass {
  SDL_GPUDevice *m_device = nullptr;
  Uint32 m_numLights = 0;
 
  void configureAtlasRegions(const ShadowPassConfig &config);
 
public:
  using Config = ShadowPassConfig;
  struct AtlasRegion {
    Uint32 x;
    Uint32 y;
    Uint32 w;
    Uint32 h;
  };

  Texture shadowMap{NoInit};
  GraphicsPipeline pipeline{NoInit};
  SDL_GPUSampler *sampler = nullptr;
  std::array<Camera, kNumLights> cam;
  std::array<AtlasRegion, kNumLights> regions;
 
  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;
 
  bool initialized() const {
    return pipeline.initialized() && (sampler != nullptr);
  }
 
  void render(CommandBuffer &cmdBuf, std::span<const OpaqueCastable> castables);
 
  void release() noexcept;
  ~ShadowMapPass() noexcept { this->release(); }
 
  auto numLights() const noexcept { return m_numLights; }
};


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

void renderShadowPassFromFrustum(CommandBuffer &cmdBuf, ShadowMapPass &passInfo,
                                 std::span<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