Function BakeDriver

BakingLab/MeshBaker.cpp:468–663

// Otherwise, it will completely bake a single texel within a bake group and flood fill
// its unbaked neighbors within the thread group.
template<typename TBaker> static bool BakeDriver(BakeThreadContext& context, TBaker& baker)
{
    if(context.CurrNumBatches == 0)
        return false;

    const uint64 batchIdx = InterlockedIncrement64(context.CurrBatch) - 1;
    if(batchIdx >= context.CurrNumBatches)
        return false;

    // Are we baking one sample per texel and progessively integrating, or are we going to
    // fully compute the final baked texel value and flood fill the neighbors?
    const bool progressiveintegration = AppSettings::SupportsProgressiveIntegration(context.CurrBakeMode, context.CurrSolveMode);

    // Figure out which 8x8 group we're working on
    const uint64 numGroupsX = (context.CurrLightMapSize + (BakeGroupSizeX - 1)) / BakeGroupSizeX;
    const uint64 numGroupsY = (context.CurrLightMapSize + (BakeGroupSizeY - 1)) / BakeGroupSizeY;
    const uint64 numBakeGroups = numGroupsX * numGroupsY;

    const uint64 groupIdx = batchIdx % numBakeGroups;
    const uint64 groupIdxX = groupIdx % numGroupsX;
    const uint64 groupIdxY = groupIdx / numGroupsX;

    const uint64 sqrtNumSamples = context.CurrNumSamples;
    const uint64 numSamplesPerTexel = sqrtNumSamples * sqrtNumSamples;

    Random& random = context.RandomGenerator;

    const bool addAreaLight = AppSettings::EnableAreaLight && AppSettings::BakeDirectAreaLight;

    // Get the set of integration samples to use, which is tiled across threads
    const uint64 numThreads = context.Samples->size();
    const IntegrationSamples& integrationSamples = (*context.Samples)[groupIdx % numThreads];

    PathTracerParams params;
    params.EnableDirectAreaLight = false;
    params.EnableDirectSun = false;
    params.EnableDiffuse = true;
    params.EnableSpecular = false;
    params.EnableBounceSpecular = false;
    params.MaxPathLength = AppSettings::MaxBakePathLength;
    params.RussianRouletteDepth = AppSettings::BakeRussianRouletteDepth;
    params.RussianRouletteProbability = AppSettings::BakeRussianRouletteProbability;
    params.RayLen = FLT_MAX;
    params.SceneBVH = context.SceneBVH;
    params.SkyCache = &context.SkyCache;
    params.EnvMaps = context.EnvMaps;

    if(progressiveintegration)
    {
        const uint64 sampleIdx = batchIdx / numBakeGroups;

        // Loop over all texels in the 8x8 group, and compute 1 sample for each
        for(uint64 groupTexelIdxX = 0; groupTexelIdxX < BakeGroupSizeX; ++groupTexelIdxX)
        {
            for(uint64 groupTexelIdxY = 0; groupTexelIdxY < BakeGroupSizeY; ++groupTexelIdxY)
            {
                const uint64 groupTexelIdx = groupTexelIdxY * BakeGroupSizeX + groupTexelIdxX;