Method allocateResources

Source/Falcor/RenderGraph/RenderGraphCompiler.cpp:264–346

}

void RenderGraphCompiler::allocateResources(ref<Device> pDevice, ResourceCache* pResourceCache)
{
    // Build list to look up execution order index from the pass
    std::unordered_map<RenderPass*, uint32_t> passToIndex;
    for (size_t i = 0; i < mExecutionList.size(); i++)
    {
        passToIndex.emplace(mExecutionList[i].pPass.get(), uint32_t(i));
    }

    for (size_t i = 0; i < mExecutionList.size(); i++)
    {
        uint32_t nodeIndex = mExecutionList[i].index;

        const DirectedGraph::Node* pNode = mGraph.mpGraph->getNode(nodeIndex);
        FALCOR_ASSERT(pNode);
        RenderPass* pCurrPass = mGraph.mNodeData[nodeIndex].pPass.get();
        const auto& passReflection = mExecutionList[i].reflector;

        auto isResourceUsed = [&](auto field)
        {
            if (!is_set(field.getFlags(), RenderPassReflection::Field::Flags::Optional))
                return true;
            if (mGraph.isGraphOutput({nodeIndex, field.getName()}))
                return true;
            for (uint32_t e = 0; e < pNode->getOutgoingEdgeCount(); e++)
            {
                const auto& edgeData = mGraph.mEdgeData[pNode->getOutgoingEdge(e)];
                if (edgeData.srcField == field.getName())
                    return true;
            }
            return false;
        };

        // Register all pass outputs
        for (size_t f = 0; f < passReflection.getFieldCount(); f++)
        {
            auto field = *passReflection.getField(f);
            std::string fullFieldName = mGraph.mNodeData[nodeIndex].name + '.' + field.getName();

            // Skip input resources, we never allocate them
            if (!is_set(field.getVisibility(), RenderPassReflection::Field::Visibility::Input))
            {
                if (isResourceUsed(field) == false)
                    continue;

                // Resource lifetime for graph outputs must extend to end of graph execution
                bool graphOutput = mGraph.isGraphOutput({nodeIndex, field.getName()});
                uint32_t lifetime = graphOutput ? uint32_t(-1) : uint32_t(i);
                if (graphOutput && field.getBindFlags() != ResourceBindFlags::None)
                    field.bindFlags(field.getBindFlags() | ResourceBindFlags::ShaderResource); // Adding ShaderResource for graph outputs
                pResourceCache->registerField(fullFieldName, field, lifetime);
            }
        }

        // Go over the pass inputs, add them as aliases to the outputs that connect to them (which should be already registered above)
        for (uint32_t e = 0; e < pNode->getIncomingEdgeCount(); e++)
        {
            uint32_t edgeIndex = pNode->getIncomingEdge(e);