Method Update

BakingLab/MeshBaker.cpp:1326–1679

}

MeshBakerStatus MeshBaker::Update(const Camera& camera, uint32 screenWidth, uint32 screenHeight,
                                  ID3D11DeviceContext* deviceContext, const Model* currentModel)
{
    Assert_(initialized);

    const bool32 showGroundTruth = AppSettings::ShowGroundTruth;

    if(currentModel != input.SceneModel)
    {
        KillBakeThreads();
        KillRenderThreads();

        sceneBVH = BVHData();
        input.SceneModel = currentModel;
        BuildBVH(*input.SceneModel, sceneBVH, input.Device, rtcDevice);

        InterlockedIncrement64(&renderTag);
        InterlockedIncrement64(&bakeTag);
        currTile = 0;
        currBakeBatch = 0;

        // Make sure that we re-extract the lightmap data
        currLightMapSize = 0;
    }

    if(showGroundTruth == false)
    {
        // Handle light map size change, which requires re-extraction of sample points
        const uint32 lightMapSize = AppSettings::LightMapResolution;
        const BakeModes bakeMode = AppSettings::BakeMode;
        const SolveModes solveMode = AppSettings::SolveMode;
        if(lightMapSize != currLightMapSize || bakeMode != currBakeMode || solveMode != currSolveMode)
        {
            KillBakeThreads();
            KillRenderThreads();

            ExtractBakePoints(input, bakePoints, gutterTexels);
            bakePointBuffer.Initialize(input.Device, sizeof(BakePoint), uint32(bakePoints.size()),
                                       false, false, false, bakePoints.data());

            const uint64 basisCount = AppSettings::BasisCount(bakeMode);
            const uint64 numTexels = lightMapSize * lightMapSize;
            for(uint64 i = 0; i < AppSettings::MaxBasisCount; ++i)
                bakeResults[i].Shutdown();

            for(uint64 i = 0; i < basisCount; ++i)
                bakeResults[i].Init(numTexels);

            const uint64 numGroupsX = (lightMapSize + (BakeGroupSizeX - 1)) / BakeGroupSizeX;
            const uint64 numGroupsY = (lightMapSize + (BakeGroupSizeY - 1)) / BakeGroupSizeY;
            if(AppSettings::SupportsProgressiveIntegration(bakeMode, solveMode))
                currNumBakeBatches = numGroupsX * numGroupsY * AppSettings::NumBakeSamples * AppSettings::NumBakeSamples;
            else
                currNumBakeBatches = numGroupsX * numGroupsY * BakeGroupSize;

            currLightMapSize = lightMapSize;
            currBakeMode = bakeMode;
            currSolveMode = solveMode;