Boilerplate.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <SDL3/SDL.h>
#include <SDL3/SDL_gpu.h>
 
#include <backends/imgui_impl_sdlgpu3.h>
#include <cstddef>
#include <vector>
 
#define MAX_POINT_LIGHTS 8
// macOS (Metal) caps the usable bindless/sampler+UBO budget lower than other
// backends, so the moving-light array must stay at 56 there. Everywhere else
// uses 64. Keep this in lockstep with the shader-side value, which is injected
// at build time via -DMAX_MOVING_POINT_LIGHTS in CMakeLists.txt.
#if defined(__APPLE__)
#define MAX_MOVING_POINT_LIGHTS 56
#else
#define MAX_MOVING_POINT_LIGHTS 64
#endif
#define MAX_SHADOW_COUNT MAX_POINT_LIGHTS
 
namespace Boilerplate
{
constexpr SDL_GPUColorTargetBlendState OVER_BLEND_MODE = {
    .src_color_blendfactor = SDL_GPU_BLENDFACTOR_SRC_ALPHA,
    .dst_color_blendfactor = SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA,
    .color_blend_op = SDL_GPU_BLENDOP_ADD,
 
    .src_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE,
    .dst_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA,
    .alpha_blend_op = SDL_GPU_BLENDOP_ADD,
    .enable_blend = true,
};

struct ShaderInfo
{
    const char* path = nullptr;
    SDL_GPUShaderStage stage = SDL_GPU_SHADERSTAGE_VERTEX;
    Uint32 samplerCount = 0;
    Uint32 uniformBufferCount = 0;
    Uint32 storageBufferCount = 0;
    Uint32 storageTextureCount = 0;
};

struct VertexInputLayout
{
    // Uint32 vertexPitch = 0;
    std::vector<SDL_GPUVertexBufferDescription> bufferDescriptions;
    std::vector<SDL_GPUVertexAttribute> attributes;
};
 
struct PipelineDescription
{
    const ShaderInfo* vertexShaderInfo = nullptr;
    const ShaderInfo* fragmentShaderInfo = nullptr;
 
    SDL_GPUShaderFormat shaderFormat;
 
    const VertexInputLayout* vertexInputLayout = nullptr;
    const SDL_GPUColorTargetDescription* colorTarget;
 
    bool reverseZ = false;
    bool depthTest = false;
    bool depthWrite = true;
 
    // SDL_GPUCullMode cullMode = SDL_GPU_CULLMODE_BACK;
    SDL_GPURasterizerState rasterizer_state{};
};

struct BufferUpload
{
    SDL_GPUBuffer* buffer = nullptr;
    const void* data = nullptr;
    size_t size = 0;
};

ImGui_ImplSDLGPU3_InitInfo createImGuiInfo(SDL_GPUDevice* device, SDL_Window* window);

SDL_GPUVertexAttribute
makeAttribute(Uint32 location, SDL_GPUVertexElementFormat format, Uint32 offset, Uint32 bufferSlot = 0);

SDL_GPUColorTargetInfo makeColorTargetClear(SDL_GPUTexture* texture, SDL_FColor clearColor);

SDL_GPUColorTargetInfo makeColorTargetLoad(SDL_GPUTexture* texture);

SDL_GPUDepthStencilTargetInfo makeDepthTarget(SDL_GPUTexture* texture, Uint8 layer, bool store,bool reverseZ);

SDL_GPUTextureSamplerBinding makeTextureSamplerBinding(SDL_GPUTexture* texture, SDL_GPUSampler* sampler);

SDL_GPUShaderFormat selectShaderFormat(SDL_GPUDevice* device);

SDL_GPUShader* loadShader(SDL_GPUDevice* device,
                          const char* path,
                          SDL_GPUShaderFormat format,
                          SDL_GPUShaderStage stage,
                          Uint32 samplerCount,
                          Uint32 uniformBufferCount,
                          Uint32 storageBufferCount,
                          Uint32 storageTextureCount);

SDL_GPUShader* loadShader(SDL_GPUDevice* device, const ShaderInfo& shaderInfo, SDL_GPUShaderFormat format);

SDL_GPUGraphicsPipeline* createGraphicsPipeline(SDL_GPUDevice* device,
                                                SDL_GPUTextureFormat& colorFormat,
                                                SDL_GPUShaderFormat shaderFormat,
                                                const ShaderInfo& vertexShaderInfo,
                                                const ShaderInfo& fragmentShaderInfo,
                                                const VertexInputLayout& vertexInputLayout,
                                                bool enableDepth = true,
                                                bool overBlending = false);

SDL_GPUGraphicsPipeline* createGraphicsPipeline(SDL_GPUDevice* device,
                                                const std::vector<SDL_GPUTextureFormat>& colorFormats,
                                                SDL_GPUShaderFormat shaderFormat,
                                                const ShaderInfo& vertexShaderInfo,
                                                const ShaderInfo& fragmentShaderInfo,
                                                const VertexInputLayout& vertexInputLayout,
                                                bool enableDepth = true,
                                                bool overBlending = false);
 
SDL_GPUGraphicsPipeline* createGraphicsDepthPipeline(SDL_GPUDevice* device, PipelineDescription pipelineDesc);
SDL_GPUBuffer* createBuffer(SDL_GPUDevice* device, size_t bufferSize, SDL_GPUBufferUsageFlags usage);

SDL_GPUTransferBuffer* createTransferBuffer(SDL_GPUDevice* device, size_t transferBufferSize, bool upload);

SDL_GPUTransferBuffer* createUploadBuffer(SDL_GPUDevice* device, size_t transferBufferSize);

void uploadBuffers(SDL_GPUDevice* device, SDL_GPUCommandBuffer* cmd, const std::vector<BufferUpload>& uploads);

SDL_GPUTexture* createEmptyTextureD32F(SDL_GPUDevice* device, Uint32 width, Uint32 height, bool cube, Uint32 arraySize);

SDL_GPUTexture* createTextureRGBA8(SDL_GPUDevice* device,
                                   Uint32 width,
                                   Uint32 height,
                                   const void* data,
                                   SDL_GPUTextureFormat format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM);
 
SDL_GPUTexture* createTextureRGBA32(SDL_GPUDevice* device, Uint32 width, Uint32 height, const void* data, SDL_GPUTextureFormat format = SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT);

SDL_GPUTexture* loadTexture(SDL_GPUDevice* device, const char* path);

SDL_GPUTexture* createDepthTexture(SDL_GPUDevice* device, Uint32 width, Uint32 height);

SDL_GPUTexture*
createSampledColorTarget(SDL_GPUDevice* device, Uint32 width, Uint32 height, SDL_GPUTextureFormat format);

SDL_GPUSampler* createLinearRepeatSampler(SDL_GPUDevice* device,bool nearest);

SDL_GPUSampler* createLinearComparisonSampler(SDL_GPUDevice* device, SDL_GPUFilter filterMode,bool reverseZ);

SDL_GPUSampler* createLinearClampSampler(SDL_GPUDevice* device);
 
} // namespace Boilerplate