RenderSettings.hpp

/*
** ETIB PROJECT, 2026
** evan
** File description:
** RenderSettings
*/
 
#pragma once
 
#include "evan/EvanPlatform.hpp"
 
#include <cstdint>
#include <limits>
 
namespace evan
{
    enum class BlendMode {
        Opaque,    
        Alpha      
    };
 
    enum class OpaqueSortMode {
        StateFirst,    
        FrontToBack    
    };
 
    enum class ColorAttachmentMode {
        DirectToSwapchain,     
        ResolveToSwapchain,    
        SwapchainImageAttachment    
    };
 
    [[nodiscard]] inline ColorAttachmentMode
        desktopColorAttachmentMode(VkSampleCountFlagBits msaaSamples) noexcept
    {
        return msaaSamples == VK_SAMPLE_COUNT_1_BIT
            ? ColorAttachmentMode::DirectToSwapchain
            : ColorAttachmentMode::ResolveToSwapchain;
    }
 
    constexpr uint32_t kOpaqueDepthBucketCount = 32;
 
    constexpr float kUnknownDepth = std::numeric_limits<float>::max();
 
    [[nodiscard]] inline uint32_t
        opaqueDepthBucket(float depth, float nearest, float span,
                          uint32_t bucketCount) noexcept
    {
        // A draw whose distance is unknown (kUnknownDepth) or cannot be
        // compared against the others (a NaN, or every draw when the visible
        // range is empty) has no place inside the front-to-back order: it
        // goes to the trailing bucket, past the last real one. The sentinel
        // is checked explicitly because it is a finite value, so it would
        // otherwise be clamped onto the last real bucket like any distance
        // past the visible range.
        if (!(span > 0.0f) || !(depth >= nearest) || depth == kUnknownDepth) {
            return bucketCount;
        }
 
        const float normalized = (depth - nearest) / span;
        // Infinity and distances past the visible range saturate on the last
        // real bucket before the conversion to avoid an out-of-range cast.
        if (!(normalized < 1.0f)) {
            return bucketCount - 1;
        }
 
        return static_cast<uint32_t>(normalized
                                     * static_cast<float>(bucketCount));
    }
 
    struct DrawSortKey {
        BlendMode blendMode   = BlendMode::Opaque;
        uint32_t depthBucket  = 0;
        float depth           = 0.0f;
        uint32_t pipelineKey  = 0;
        uint32_t materialID   = 0;
        VkBuffer vertexBuffer = VK_NULL_HANDLE;
        VkBuffer indexBuffer  = VK_NULL_HANDLE;
        uint32_t sequence     = 0;
    };
 
    [[nodiscard]] inline bool drawSortKeyLess(const DrawSortKey &lhs,
                                              const DrawSortKey &rhs) noexcept
    {
        if (lhs.blendMode != rhs.blendMode) {
            return static_cast<int>(lhs.blendMode)
                < static_cast<int>(rhs.blendMode);
        }
 
        if (lhs.blendMode == BlendMode::Alpha) {
            // Blended geometry is composited back-to-front. Depth decides
            // before state: grouping materials by pipeline first would blend
            // them in the wrong order.
            if (lhs.depth != rhs.depth) {
                return lhs.depth > rhs.depth;
            }
        } else if (lhs.depthBucket != rhs.depthBucket) {
            // Opaque geometry goes front-to-back. The bucket, not the exact
            // distance, so that draws of the same bucket keep their state
            // ordering and still merge into batching.
            return lhs.depthBucket < rhs.depthBucket;
        }
 
        if (lhs.pipelineKey != rhs.pipelineKey) {
            return lhs.pipelineKey < rhs.pipelineKey;
        }
        if (lhs.materialID != rhs.materialID) {
            return lhs.materialID < rhs.materialID;
        }
        if (lhs.vertexBuffer != rhs.vertexBuffer) {
            return lhs.vertexBuffer < rhs.vertexBuffer;
        }
        if (lhs.indexBuffer != rhs.indexBuffer) {
            return lhs.indexBuffer < rhs.indexBuffer;
        }
        return lhs.sequence < rhs.sequence;
    }
 
    struct RenderSettings {
        VkSampleCountFlagBits msaaSamples = VK_SAMPLE_COUNT_1_BIT;
 
        OpaqueSortMode opaqueSort = OpaqueSortMode::FrontToBack;
    };
}    // namespace evan