#include <RenderBucket.h>

Public Types
enum	Type : uint8_t { ShadowMap , GBuffer , Opaque , Transparent , UI , Debug , Count }

Public Member Functions
void	Submit (const RenderCommand &command)

void	Sort ()

void	Flush ()

void	Clear ()

size_t	GetCommandCount () const

size_t	GetMemoryUsage () const

Protected Attributes
std::vector< RenderCommand >	m_commands

bool	m_isSorted = true

Detailed Description

Definition at line 8 of file RenderBucket.h.

Member Enumeration Documentation

◆ Type

enum Elevate::RenderBucket::Type : uint8_t

Enumerator
ShadowMap
GBuffer
Opaque
Transparent
UI
Debug
Count

Definition at line 11 of file RenderBucket.h.

        {
            ShadowMap,
            GBuffer,
            Opaque,
            Transparent,
            UI,
            Debug,
            Count // Only used to keep the number of bucket at compile time
        };

Member Function Documentation

◆ Clear()

void Elevate::RenderBucket::Clear ( )

Definition at line 25 of file RenderBucket.cpp.

    {
        m_commands.clear();
        m_isSorted = false;
    }

◆ Flush()

void Elevate::RenderBucket::Flush ( )

Definition at line 12 of file RenderBucket.cpp.

    {
        if (m_commands.empty()) return;
 
        // Sends each command to be executed by the renderer
        for (const auto& command : m_commands)
        {
            Renderer::Dispatch(command);
        }
 
        Clear();
    }

◆ GetCommandCount()

size_t Elevate::RenderBucket::GetCommandCount ( ) const

Definition at line 77 of file RenderBucket.cpp.

    {
        return m_commands.size();
    }

◆ GetMemoryUsage()

size_t Elevate::RenderBucket::GetMemoryUsage ( ) const

Definition at line 82 of file RenderBucket.cpp.

    {
        return GetCommandCount() * sizeof(RenderCommand);
    }

◆ Sort()

void Elevate::RenderBucket::Sort ( )

Definition at line 31 of file RenderBucket.cpp.

    {
        if (m_commands.empty() || m_isSorted) return;
 
        const size_t n = m_commands.size();
        std::vector<RenderCommand> tempBuffer(n);
 
        RenderCommand* src = m_commands.data();
        RenderCommand* dst = tempBuffer.data();
 
        const int bitsPerPass = 8;
        const int bucketCount = 1 << bitsPerPass;
        const uint32_t mask = bucketCount - 1;
        const uint16_t keySizeBits = sizeof(m_commands[0].m_SortingKey) * 8;
 
        for (uint16_t shift = 0; shift < keySizeBits; shift += bitsPerPass)
        {
            uint32_t count[bucketCount] = { 0 };
 
            for (size_t i = 0; i < n; i++)
            {
                count[(src[i].m_SortingKey >> shift) & mask]++;
            }
 
            for (int i = 1; i < bucketCount; ++i)
            {
                count[i] += count[i - 1];
            }
 
            for (long long i = (long long)m_commands.size() - 1; i >= 0; --i)
            {
                uint32_t bucket = (src[i].m_SortingKey >> shift) & mask;
                dst[--count[bucket]] = src[i];
            }
 
            std::swap(src, dst);
        }
 
        if (src != m_commands.data())
        {
            std::copy(tempBuffer.begin(), tempBuffer.end(), m_commands.begin());
        }
 
        m_isSorted = true;
    }

◆ Submit()

void Elevate::RenderBucket::Submit ( const RenderCommand & command )

Definition at line 6 of file RenderBucket.cpp.

    {
        m_commands.push_back(command);
        m_isSorted = false;
    }

Member Data Documentation

◆ m_commands

std::vector<RenderCommand> Elevate::RenderBucket::m_commands

protected

Definition at line 31 of file RenderBucket.h.

◆ m_isSorted

bool Elevate::RenderBucket::m_isSorted = true