Method ProbeVisibilityGraph

core/src/core/path_visibility.cpp:115–187

// --------------------------------------------------------------------------------------------------------------------

ProbeVisibilityGraph::ProbeVisibilityGraph(const IScene& scene,
                                           const ProbeBatch& probes,
                                           const ProbeVisibilityTester& visTester,
                                           float radius,
                                           float threshold,
                                           float visRange,
                                           int numThreads,
                                           JobGraph& jobGraph,
                                           std::atomic<bool>& cancel,
                                           ProgressCallback progressCallback,
                                           void* callbackUserData)
    : mAdjacent(probes.numProbes())
    , mNumJobsRemaining(0)
{
    PROFILE_FUNCTION();

    // For any 2 probe indices (i, j), we will only check visibility if i > j.
    // We will divide the work of constructing the visibility graph into a set of jobs, where each job involves
    // constructing one or more rows of the adjacency list (mAdjacent[i]). A given row will never be processed by
    // multiple threads concurrently.
    auto numProbes = probes.numProbes();
    auto numProbesPerJob = 1;

    auto numProbesThisJob = 0;
    auto firstProbeThisJob = 0;
    for (auto i = 0; i < numProbes; i++)
    {
        numProbesThisJob++;
        if (numProbesThisJob == 1)
        {
            firstProbeThisJob = i;
        }

        if (numProbesThisJob == numProbesPerJob ||
            i == numProbes - 1)
        {
            jobGraph.addJob([this, firstProbeThisJob, numProbesThisJob, radius, threshold, visRange, &scene, &probes, &visTester](int threadIndex, std::atomic<bool>& cancel)
            {
                for (auto i = firstProbeThisJob; i < firstProbeThisJob + numProbesThisJob; i++)
                {
                    for (auto j = 0; j < i; ++j)
                    {
                        if (visTester.areProbesTooFar(probes, i, j, visRange))
                            continue;

                        if (!visTester.areProbesVisible(scene, probes, i, j, radius, threshold))
                            continue;

                        auto cost = (probes[i].influence.center - probes[j].influence.center).length();

                        mAdjacent[i].push_back(AdjacencyListEntry{j, cost});
                    }
                }

                // The last job we process "completes" the adjacency list, by making sure that if we have an edge from
                // i to j, we also have an edge from j to i.
                if (std::atomic_fetch_sub_explicit(&mNumJobsRemaining, 1, std::memory_order_seq_cst) == 1)
                {