Method SortDrawCalls

Source/Engine/Renderer/RenderList.cpp:790–893

}

void RenderList::SortDrawCalls(const RenderContext& renderContext, bool reverseDistance, DrawCallsList& list, const RenderListBuffer<DrawCall>& drawCalls, DrawCallsListType listType, DrawPass pass)
{
    PROFILE_CPU();
    PROFILE_MEM(GraphicsCommands);
    const auto* drawCallsData = drawCalls.Get();
    const auto* listData = list.Indices.Get();
    const int32 listSize = list.Indices.Count();
    ZoneValue(listSize);

    // Use shared memory from renderer allocator
    RenderListAlloc allocs[3];
    uint64* sortedKeys = allocs[0].Init<uint64>(this, listSize);
    uint64* tempKeys = allocs[1].Init<uint64>(this, listSize);
    int32* tempIndices = allocs[2].Init<int32>(this, listSize);

    // Setup sort keys
    if (reverseDistance)
    {
        if (listType == DrawCallsListType::Forward)
        {
            // Transparency uses distance to take precedence over batching efficiency for correct draw order
            for (int32 i = 0; i < listSize; i++)
            {
                const DrawCall& drawCall = drawCallsData[listData[i]];
                PackedSortKey key = *(PackedSortKey*)&drawCall.SortKey;
                PackedSortKeyDistance forwardKey;
                forwardKey.BatchKey = key.BatchKey;
                forwardKey.DistanceKey = key.DistanceKey ^ MAX_uint32; // Reverse depth
                forwardKey.DrawKey = key.DrawKey;
                forwardKey.SortKey = key.SortKey ^ MAX_uint8; // Reverse sort order
                sortedKeys[i] = *(uint64*)&forwardKey;
            }
        }
        else
        {
            for (int32 i = 0; i < listSize; i++)
            {
                const DrawCall& drawCall = drawCallsData[listData[i]];
                PackedSortKey key = *(PackedSortKey*)&drawCall.SortKey;
                key.DistanceKey ^= MAX_uint32; // Reverse depth
                key.SortKey ^= MAX_uint8; // Reverse sort order
                sortedKeys[i] = *(uint64*)&key;
            }
        }
    }
    else
    {
        for (int32 i = 0; i < listSize; i++)
            sortedKeys[i] = drawCallsData[listData[i]].SortKey;
    }

    // Sort draw calls indices
    int32* resultIndices = list.Indices.Get();
    Sorting::RadixSort(sortedKeys, resultIndices, tempKeys, tempIndices, listSize);
    if (resultIndices != list.Indices.Get())
        Platform::MemoryCopy(list.Indices.Get(), resultIndices, sizeof(int32) * listSize);

    // Perform draw calls batching