Function MakeSortBuffer

engine/render/src/render/render.cpp:570–680

Compute new sort values for everything that matches tag_mask

    // Compute new sort values for everything that matches tag_mask
    static void MakeSortBuffer(HRenderContext context, uint32_t tag_count, dmhash_t* tags, SortOrder sort_order)
    {
        DM_PROFILE("MakeSortBuffer");

        const uint32_t required_capacity = context->m_RenderListSortIndices.Capacity();
        // SetCapacity does early out if they are the same, so just call anyway.
        context->m_RenderListSortBuffer.SetCapacity(required_capacity);
        context->m_RenderListSortBuffer.SetSize(0);
        context->m_RenderListSortValues.SetCapacity(required_capacity);
        context->m_RenderListSortValues.SetSize(context->m_RenderListSortIndices.Size());

        RenderListSortValue* sort_values = context->m_RenderListSortValues.Begin();
        RenderListEntry* entries = context->m_RenderList.Begin();

        const Matrix4& transform = context->m_ViewProj;

        float minZW = FLT_MAX;
        float maxZW = -FLT_MAX;

        RenderListRange* ranges = context->m_RenderListRanges.Begin();
        uint32_t num_ranges = context->m_RenderListRanges.Size();
        for( uint32_t r = 0; r < num_ranges; ++r)
        {
            RenderListRange& range = ranges[r];

            MaterialTagList taglist;
            dmRender::GetMaterialTagList(context, range.m_TagListKey, &taglist);

            range.m_Skip = 0;
            if (tag_count > 0 && !dmRender::MatchMaterialTags(taglist.m_Count, taglist.m_Tags, tag_count, tags))
            {
                range.m_Skip = 1;
                continue;
            }

            // Write z values...
            int num_visibility_skipped = 0;
            for (uint32_t i = range.m_Start; i < range.m_Start+range.m_Count; ++i)
            {
                uint32_t idx = context->m_RenderListSortIndices[i];
                RenderListEntry* entry = &entries[idx];
                if (entry->m_Visibility == dmRender::VISIBILITY_NONE)
                {
                    num_visibility_skipped++;
                    continue;
                }

                if (entry->m_MajorOrder != RENDER_ORDER_WORLD)
                {
                    continue; // Could perhaps break here, if we also sorted on the major order (cost more when I tested it /MAWE)
                }

                const Vector4 res = transform * entry->m_WorldPosition;
                const float zw = res.getZ() / res.getW();
                sort_values[idx].m_ZW = zw;
                if (zw < minZW) minZW = zw;
                if (zw > maxZW) maxZW = zw;
            }