RenderContext.h

Go to the documentation of this file.

#pragma once
 
#include "Device.h"
#include "CommandBuffer.h"
#include "Texture.h"
#include "Mesh.h"
#include "Window.h"
 
#include <span>
#include <SDL3/SDL_gpu.h>
 
namespace candlewick {
 
inline constexpr int sdlSampleToValue(SDL_GPUSampleCount samples) {
  switch (samples) {
  case SDL_GPU_SAMPLECOUNT_1:
    return 1;
  case SDL_GPU_SAMPLECOUNT_2:
    return 2;
  case SDL_GPU_SAMPLECOUNT_4:
    return 4;
  case SDL_GPU_SAMPLECOUNT_8:
    return 8;
  default:
    return 0;
  }
}

struct RenderContext {
private:
  Texture colorMsaa{NoInit};
  Texture colorBuffer{NoInit}; // no MSAA
  Texture depthBuffer{NoInit}; // no MSAA
  bool m_msaaEnabled = false;
  SDL_GPUTexture *swapchain{nullptr};
 
  void createMsaaTargets(SDL_GPUSampleCount samples);
  void createRenderTargets(SDL_GPUTextureFormat suggested_depth_format);
 
public:
  Device device;
  Window window;
 
  RenderContext(NoInitT) : device(NoInit), window(nullptr) {}
  RenderContext(Device &&device, Window &&window,
                SDL_GPUTextureFormat suggested_depth_format =
                    SDL_GPU_TEXTUREFORMAT_INVALID);
 
  RenderContext(RenderContext &&) noexcept = default;
  RenderContext &operator=(RenderContext &&) noexcept = default;
 
  const Texture &colorTarget() const {
    return (m_msaaEnabled && colorMsaa) ? colorMsaa : colorBuffer;
  }
 
  const Texture &depthTarget() const { return depthBuffer; }
 
  const Texture &resolvedColorTarget() const { return colorBuffer; }
 
  bool msaaEnabled() const { return m_msaaEnabled; }
 
  SDL_GPUSampleCount getMsaaSampleCount() const {
    if (m_msaaEnabled && colorMsaa) {
      return colorMsaa.sampleCount();
    }
    return SDL_GPU_SAMPLECOUNT_1;
  }
 
  void enableMSAA(SDL_GPUSampleCount samples) {
    if (samples > SDL_GPU_SAMPLECOUNT_1) {
      m_msaaEnabled = true;
      createMsaaTargets(samples);
      if (int sample_size = sdlSampleToValue(samples)) {
        spdlog::info("MSAA enabled with {:d} samples", sample_size);
      } else {
        terminate_with_message("Unrecognized sample count {:d}", sample_size);
      }
    } else {
      disableMSAA();
    }
  }
 
  void disableMSAA() {
    m_msaaEnabled = false;
    colorMsaa.destroy();
    spdlog::info("MSAA disabled");
  }
 
  bool initialized() const { return bool(device); }

  CommandBuffer acquireCommandBuffer() const { return CommandBuffer(device); }

  bool waitAndAcquireSwapchain(CommandBuffer &command_buffer);

  bool acquireSwapchain(CommandBuffer &command_buffer);

  bool waitForSwapchain() { return SDL_WaitForGPUSwapchain(device, window); }

  void presentToSwapchain(CommandBuffer &command_buffer);
 
  SDL_GPUTextureFormat getSwapchainTextureFormat() const {
    return SDL_GetGPUSwapchainTextureFormat(device, window);
  }

  inline bool hasDepthTexture() const { return depthBuffer; }
 
  inline void setSwapchainParameters(SDL_GPUSwapchainComposition composition,
                                     SDL_GPUPresentMode present_mode) {
    SDL_SetGPUSwapchainParameters(device, window, composition, present_mode);
  }
 
  SDL_GPUTextureFormat colorFormat() const { return colorBuffer.format(); }
  SDL_GPUTextureFormat depthFormat() const { return depthBuffer.format(); }
 
  void destroy() noexcept;
  ~RenderContext() noexcept { this->destroy(); }
};
 
namespace rend {

  void bindMesh(SDL_GPURenderPass *pass, const Mesh &mesh);

  void bindMeshView(SDL_GPURenderPass *pass, const MeshView &view);

  void drawViews(SDL_GPURenderPass *pass, std::span<const MeshView> meshViews,
                 Uint32 numInstances = 1);

  inline void draw(SDL_GPURenderPass *pass, const Mesh &mesh,
                   Uint32 numInstances = 1) {
    drawViews(pass, mesh.views(), numInstances);
  }

  void drawView(SDL_GPURenderPass *pass, const MeshView &mesh,
                Uint32 numInstances = 1);

  inline void
  bindVertexSamplers(SDL_GPURenderPass *pass, Uint32 first_slot,
                     std::span<const SDL_GPUTextureSamplerBinding> bindings) {
    SDL_BindGPUVertexSamplers(pass, first_slot, bindings.data(),
                              Uint32(bindings.size()));
  }

  inline void bindVertexSamplers(
      SDL_GPURenderPass *pass, Uint32 first_slot,
      std::initializer_list<SDL_GPUTextureSamplerBinding> sampler_bindings) {
    bindVertexSamplers(pass, first_slot, std::span(sampler_bindings));
  }

  inline void
  bindFragmentSamplers(SDL_GPURenderPass *pass, Uint32 first_slot,
                       std::span<const SDL_GPUTextureSamplerBinding> bindings) {
    SDL_BindGPUFragmentSamplers(pass, first_slot, bindings.data(),
                                Uint32(bindings.size()));
  }

  inline void bindFragmentSamplers(
      SDL_GPURenderPass *pass, Uint32 first_slot,
      std::initializer_list<SDL_GPUTextureSamplerBinding> sampler_bindings) {
    bindFragmentSamplers(pass, first_slot, std::span(sampler_bindings));
  }
 
} // namespace rend
} // namespace candlewick