Method optimizeMaterials

Source/Falcor/Scene/Material/MaterialSystem.cpp:380–446

    }

    void MaterialSystem::optimizeMaterials()
    {
        // Gather a list of all textures to analyze.
        std::vector<std::pair<ref<Material>, Material::TextureSlot>> materialSlots;
        std::vector<ref<Texture>> textures;
        size_t maxCount = mMaterials.size() * (size_t)Material::TextureSlot::Count;
        materialSlots.reserve(maxCount);
        textures.reserve(maxCount);

        for (const auto& pMaterial : mMaterials)
        {
            for (uint32_t i = 0; i < (uint32_t)Material::TextureSlot::Count; i++)
            {
                auto slot = (Material::TextureSlot)i;
                if (auto pTexture = pMaterial->getTexture(slot))
                {
                    materialSlots.push_back({ pMaterial, slot });
                    textures.push_back(pTexture);
                }
            }
        }

        if (textures.empty()) return;

        // Analyze the textures.
        logInfo("Analyzing {} material textures.", textures.size());

        RenderContext* pRenderContext = mpDevice->getRenderContext();

        TextureAnalyzer analyzer(mpDevice);
        auto pResults = mpDevice->createBuffer(textures.size() * TextureAnalyzer::getResultSize(), ResourceBindFlags::UnorderedAccess);
        analyzer.analyze(pRenderContext, textures, pResults);

        // Copy result to staging buffer for readback.
        // This is mostly to avoid a full flush and the associated perf warning.
        // We do not have any other useful GPU work, but unrelated GPU tasks can be in flight.
        auto pResultsStaging = mpDevice->createBuffer(textures.size() * TextureAnalyzer::getResultSize(), ResourceBindFlags::None, MemoryType::ReadBack);
        pRenderContext->copyResource(pResultsStaging.get(), pResults.get());
        pRenderContext->submit(false);
        pRenderContext->signal(mpFence.get());

        // Wait for results to become available. Then optimize the materials.
        mpFence->wait();
        const TextureAnalyzer::Result* results = static_cast<const TextureAnalyzer::Result*>(pResultsStaging->map());
        Material::TextureOptimizationStats stats = {};

        for (size_t i = 0; i < textures.size(); i++)
        {
            materialSlots[i].first->optimizeTexture(materialSlots[i].second, results[i], stats);
        }

        pResultsStaging->unmap();

        // Log optimization stats.
        if (size_t totalRemoved = std::accumulate(stats.texturesRemoved.begin(), stats.texturesRemoved.end(), 0ull); totalRemoved > 0)
        {
            logInfo("Optimized materials by removing {} constant textures.", totalRemoved);
            for (size_t slot = 0; slot < (size_t)Material::TextureSlot::Count; slot++)