Method findPaths

core/src/core/path_simulator.cpp:125–215

First, find the source-probe (the probe nearest to the source), and the listener-probes (all probes which influence the listener). For each listener-probe, query the baked data for the shortest path from the source-probe to the listener-probe. Weights are calculated for the paths reaching each listener-probe, such that if the listener is closer to a given listener-probe, its corresponding weight

//
// Finally, all the paths that haven't been discarded are weighted and summed into a set of SH and EQ coefficients.
bool PathSimulator::findPaths(const Vector3f& source,
                              const Vector3f& listener,
                              const IScene& scene,
                              const ProbeBatch& probes,
                              const ProbeNeighborhood& sourceProbes,
                              const ProbeNeighborhood& listenerProbes,
                              float radius,
                              float threshold,
                              float visRange,
                              int order,
                              bool enableValidation,
                              bool findAlternatePaths,
                              bool simplifyPaths,
                              bool realTimeVis,
                              float* eqGains,
                              float* coeffs,
                              const DistanceAttenuationModel& distanceAttenuationModel,
                              const DeviationModel& deviationModel,
                              Vector3f* avgDirection,
                              float* distanceRatio,
                              float* totalDeviation,
                              ValidationRayVisualizationCallback validationRayVisualization,
                              void* userData,
                              bool forceDirectOcclusion)
{
    PROFILE_FUNCTION();

    const int kMaxPaths = 64;

    int numPaths = 0;
    SoundPath paths[kMaxPaths];
    float pathWeights[kMaxPaths];
    int starts[kMaxPaths];
    int ends[kMaxPaths];

    if (scene.isOccluded(listener, source) || forceDirectOcclusion)
    {
        if (sourceProbes.hasValidProbes() && listenerProbes.hasValidProbes())
        {
            BakedDataIdentifier identifier;
            identifier.variation = BakedDataVariation::Dynamic;
            identifier.type = BakedDataType::Pathing;

            if (probes.hasData(identifier))
            {
                const auto& bakedPathData = static_cast<const BakedPathData&>(probes[identifier]);

                if (sEnablePathsFromAllSourceProbes)
                {
                    for (auto i = 0; i < sourceProbes.numProbes(); ++i)
                    {
                        findPathsFromSourceProbe(scene, probes, sourceProbes, listenerProbes, bakedPathData, i, sourceProbes.weights[i],
                                                 radius, threshold, visRange, enableValidation, findAlternatePaths, simplifyPaths, realTimeVis,
                                                 validationRayVisualization, userData, numPaths, paths, pathWeights, starts, ends);
                    }
                }
                else
                {