Function BenchmarkLoop

src/common/base/Benchmark.cpp:151–214

}

float BenchmarkLoop(const std::vector<TimeStamp> &timeStamps, Camera *pCam, std::string& outScreenShotName)
{
    if (bm.frame < bm.warmUpFrames) // warmup
    {
        bm.frame++;
        return bm.time;
    }

    if (bm.time > bm.timeEnd) // are we done yet?
    {
        fclose(bm.f);

        if (bm.exitWhenTimeEnds)
        {
            PostQuitMessage(0);
            return bm.time; 
        }
    }

    SaveTimestamps(bm.time, timeStamps);
        
    // animate camera
    if (bm.m_animationFound && (pCam != NULL))
    {
        // if GLTF has camera with cameraID then use that camera and its animation
        if (bm.cameraId >= 0)
        {                
            bm.m_pGltfLoader->GetCamera(bm.cameraId, pCam);
        }
        else
        {
            // cameraID is -1, then use our sequence
            if (bm.time >= bm.m_nextTime)
            {
                bm.m_nextTime = bm.m_sequence.GetNextKeyTime(bm.time);

                const BenchmarkSequence::KeyFrame keyFrame = bm.m_sequence.GetNextKeyFrame(bm.time);
                
                const bool bValidKeyframe = keyFrame.m_time >= 0;
                if (bValidKeyframe)
                {
                    if (keyFrame.m_camera == -1)
                    {
                        pCam->LookAt(keyFrame.m_from, keyFrame.m_to);
                    }
                    else
                    {
                        bm.m_pGltfLoader->GetCamera(keyFrame.m_camera, pCam);
                    }

                    const bool bShouldTakeScreenshot = !keyFrame.m_screenShotName.empty();
                    if (bShouldTakeScreenshot)
                    {
                        outScreenShotName = keyFrame.m_screenShotName;
                    }
                }
            }
        }