World3DPipeline.cpp

Go to the documentation of this file.

#include "World3DPipeline.hpp"
 
#include "MeshGPUResources.hpp"
 
#include <SDL3/SDL.h>
 
#include <array>
#include <cstddef>
#include <utility>
 
namespace monopoly::engine
{
    std::optional<SDL_GPUTextureFormat> chooseWorld3DDepthFormat(
        SDL_GPUDevice* device) noexcept
    {
        if (!device) return std::nullopt;
        constexpr std::array candidates{
            SDL_GPU_TEXTUREFORMAT_D32_FLOAT,
            SDL_GPU_TEXTUREFORMAT_D24_UNORM,
            SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT,
            SDL_GPU_TEXTUREFORMAT_D16_UNORM
        };
        for (const auto format : candidates)
        {
            if (SDL_GPUTextureSupportsFormat(device, format,
                    SDL_GPU_TEXTURETYPE_2D,
                    SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET))
                return format;
        }
        return std::nullopt;
    }
 
    World3DPipeline::~World3DPipeline()
    {
        reset();
    }
    World3DPipeline::World3DPipeline(World3DPipeline&& other) noexcept
    {
        *this = std::move(other);
    }
 
    World3DPipeline& World3DPipeline::operator=(World3DPipeline&& other) noexcept
    {
        if (this == &other) return *this;
        reset();
        device_ = std::exchange(other.device_, nullptr);
        pipeline_ = std::exchange(other.pipeline_, nullptr);
        shadowPipeline_ = std::exchange(other.shadowPipeline_, nullptr);
        doubleSidedPipeline_ = std::exchange(other.doubleSidedPipeline_, nullptr);
        depthFormat_ = std::exchange(other.depthFormat_, SDL_GPU_TEXTUREFORMAT_INVALID);
        shaders_ = std::move(other.shaders_);
        return *this;
    }
 
    void World3DPipeline::reset() noexcept
    {
        if (device_ && doubleSidedPipeline_)
            SDL_ReleaseGPUGraphicsPipeline(device_, doubleSidedPipeline_);
        if (device_ && shadowPipeline_)
            SDL_ReleaseGPUGraphicsPipeline(device_, shadowPipeline_);
        if (device_ && pipeline_)
            SDL_ReleaseGPUGraphicsPipeline(device_, pipeline_);
        shadowPipeline_ = nullptr;
        doubleSidedPipeline_ = nullptr;
        pipeline_ = nullptr;
        shaders_.reset();
        depthFormat_ = SDL_GPU_TEXTUREFORMAT_INVALID;
        device_ = nullptr;
    }
 
    std::expected<World3DPipeline, World3DPipelineError> World3DPipeline::load(
        SDL_GPUDevice* device,
        const std::filesystem::path& shaderDirectory,
        SDL_GPUTextureFormat colorFormat, bool modernPBR, SDL_GPUSampleCount samples)
    {
        if (!device)
            return std::unexpected(World3DPipelineError{
                World3DPipelineErrorCode::MissingDevice, "missing SDL GPU device", {}});
        if (colorFormat == SDL_GPU_TEXTUREFORMAT_INVALID)
            return std::unexpected(World3DPipelineError{
                World3DPipelineErrorCode::InvalidColorFormat,
                "invalid World3D color target format", {}});
 
        const auto depthFormat = chooseWorld3DDepthFormat(device);
        if (!depthFormat)
            return std::unexpected(World3DPipelineError{
                World3DPipelineErrorCode::UnsupportedDepthFormat,
                "device exposes no supported World3D depth target", {}});
 
        auto shaders = World3DShaderSet::load(device, shaderDirectory, modernPBR);
        if (!shaders)
            return std::unexpected(World3DPipelineError{
                World3DPipelineErrorCode::ShaderLoadFailed,
                shaders.error().detail,
                shaders.error()});
 
        static_assert(sizeof(MeshGPUVertex) == sizeof(float) * 12U);
        static_assert(offsetof(MeshGPUVertex, position) == 0U);
        static_assert(offsetof(MeshGPUVertex, normal) == sizeof(float) * 3U);
        static_assert(offsetof(MeshGPUVertex, uv) == sizeof(float) * 6U);
        static_assert(offsetof(MeshGPUVertex, tangent) == sizeof(float) * 8U);
 
        const SDL_GPUVertexBufferDescription vertexBuffer{
            0U,
            static_cast<Uint32>(sizeof(MeshGPUVertex)),
            SDL_GPU_VERTEXINPUTRATE_VERTEX,
            0U
        };
        const std::array<SDL_GPUVertexAttribute, 4> attributes{{
            {0U, 0U, SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3,
                static_cast<Uint32>(offsetof(MeshGPUVertex, position))},
            {1U, 0U, SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3,
                static_cast<Uint32>(offsetof(MeshGPUVertex, normal))},
            {2U, 0U, SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2,
                static_cast<Uint32>(offsetof(MeshGPUVertex, uv))},
            {3U, 0U, SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4,
                static_cast<Uint32>(offsetof(MeshGPUVertex, tangent))}
        }};
 
        SDL_GPUColorTargetDescription colorTarget{};
        colorTarget.format = colorFormat;
        colorTarget.blend_state.enable_blend = false;
        colorTarget.blend_state.enable_color_write_mask = false;
 
        SDL_GPUGraphicsPipelineCreateInfo info{};
        info.vertex_shader = shaders->vertex();
        info.fragment_shader = shaders->fragment();
        info.vertex_input_state.vertex_buffer_descriptions = &vertexBuffer;
        info.vertex_input_state.num_vertex_buffers = 1U;
        info.vertex_input_state.vertex_attributes = attributes.data();
        info.vertex_input_state.num_vertex_attributes =
            modernPBR ? static_cast<Uint32>(attributes.size()) : 3U;
        info.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
 
        info.rasterizer_state.fill_mode = SDL_GPU_FILLMODE_FILL;
        // D3DDevice::SetInitialRenderingStates leaves CULLMODE at the
        // IDirect3DDevice3 default D3DCULL_CCW: clockwise fronts survive.
        // The shadow pipeline inherits this same rasterizer state below.
        info.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_BACK;
        info.rasterizer_state.front_face = SDL_GPU_FRONTFACE_CLOCKWISE;
        info.rasterizer_state.enable_depth_clip = true;
        info.multisample_state.sample_count = samples;
 
        info.depth_stencil_state.compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL;
        info.depth_stencil_state.enable_depth_test = true;
        info.depth_stencil_state.enable_depth_write = true;
        info.depth_stencil_state.enable_stencil_test = false;
 
        info.target_info.color_target_descriptions = &colorTarget;
        info.target_info.num_color_targets = 1U;
        info.target_info.depth_stencil_format = *depthFormat;
        info.target_info.has_depth_stencil_target = true;
 
        SDL_GPUGraphicsPipeline* pipeline =
            SDL_CreateGPUGraphicsPipeline(device, &info);
        if (!pipeline)
            return std::unexpected(World3DPipelineError{
                World3DPipelineErrorCode::PipelineCreateFailed,
                SDL_GetError(), {}});
 
        if (modernPBR)
        {
            info.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_NONE;
            SDL_GPUGraphicsPipeline* doubleSided =
                SDL_CreateGPUGraphicsPipeline(device, &info);
            if (!doubleSided)
            {
                SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
                return std::unexpected(World3DPipelineError{
                    World3DPipelineErrorCode::PipelineCreateFailed,
                    SDL_GetError(), {}});
            }
            World3DPipeline result;
            result.device_ = device;
            result.pipeline_ = pipeline;
            result.doubleSidedPipeline_ = doubleSided;
            result.depthFormat_ = *depthFormat;
            result.shaders_ = std::move(*shaders);
            return result;
        }
 
        // UDPieces.cpp + UDUTILS_ConvertToShadow use D3DBLEND_ZERO /
        // D3DBLEND_SRCALPHA for the eleven token-shadow meshes. Their texture
        // stores transmissivity in alpha: black texels darken the destination,
        // white texels leave it untouched.
        colorTarget.blend_state.enable_blend = true;
        colorTarget.blend_state.src_color_blendfactor = SDL_GPU_BLENDFACTOR_ZERO;
        colorTarget.blend_state.dst_color_blendfactor = SDL_GPU_BLENDFACTOR_SRC_ALPHA;
        colorTarget.blend_state.color_blend_op = SDL_GPU_BLENDOP_ADD;
        colorTarget.blend_state.src_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ZERO;
        colorTarget.blend_state.dst_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE;
        colorTarget.blend_state.alpha_blend_op = SDL_GPU_BLENDOP_ADD;
 
        SDL_GPUGraphicsPipeline* shadowPipeline =
            SDL_CreateGPUGraphicsPipeline(device, &info);
        if (!shadowPipeline)
        {
            SDL_ReleaseGPUGraphicsPipeline(device, pipeline);
            return std::unexpected(World3DPipelineError{
                World3DPipelineErrorCode::PipelineCreateFailed,
                SDL_GetError(), {}});
        }
 
        World3DPipeline result;
        result.device_ = device;
        result.pipeline_ = pipeline;
        result.shadowPipeline_ = shadowPipeline;
        result.depthFormat_ = *depthFormat;
        result.shaders_ = std::move(*shaders);
        return result;
    }
}