View difference between Paste ID: KSQTSN5F and fzkefb9N

 sf::Clock frameClock;
 
 double desiredRefreshRate = 60.0;
 double frameSkipPreventionPenalty = desiredRefreshRate / 300;
 double definiteFramerateTarget = desiredRefreshRate - frameSkipPreventionPenalty;
 const sf::Time minAdaptiveFrameTimeMicros = sf::microseconds((sf::Int64) (1000000.0f / (definiteFramerateTarget * 2.0)));
 const sf::Time maxAdaptiveFrameTimeMicros = sf::microseconds((sf::Int64) (1000000.0f / (definiteFramerateTarget * 0.5)));
 
 const sf::Time idealFrameTime = sf::microseconds((sf::Int64) (1000000.0 / definiteFramerateTarget));
 
 // Frame time backlog
 const int frameTimeMemorySize = (int) (desiredRefreshRate * 1.5 + 2); // Adapt within 1.5 seconds
 sf::Int64* frameTimeMemoryMicros = (sf::Int64*) malloc(sizeof(sf::Int64) * frameTimeMemorySize);
 
 // Start filled with ideal frame time
 std::fill_n(frameTimeMemoryMicros, frameTimeMemorySize, idealFrameTime.asMicroseconds());
 sf::Int64 frameTimeMemoryMicrosSum = frameTimeMemorySize * idealFrameTime.asMicroseconds();
 
 int frameTimeOldestMemorySlot = 0;
 sf::Int64 recentMicros;
 sf::Int64 oldMicros;
 
 sf::Time assumedFrameTime = idealFrameTime;
 sf::Time elapsedFrameTime;
 sf::Time frameTime;
 sf::Time sceneTime;
 sf::Time previousSceneTime;
 sf::Time intendedSleepDuration;
 sf::Time afterSleepTime;
 sf::Time actualSleepDuration;
 sf::Time oversleepDuration;
 sf::Time correctiveFrameTime;
 
 while (window->isOpen()) {
 
 	frameClock.restart();
 
 	sceneTime = sceneClock.getElapsedTime();
 	frameTime = sceneTime - previousSceneTime;
 
 	if (frameTime < sf::Time::Zero) { // The clock was reset
 		frameTime = sceneTime;
 		previousSceneTime = sf::Time::Zero;
 	} else {
 		previousSceneTime = sceneTime;
 	}
 
 	if (frameTime > sf::Time::Zero) {
 		parseInput(frameTime);
 		renderScene(sceneTime);
 		window->display(); // Swap buffers
 		glFlush();
 	}
 
-	//std::cout << "Adaptive FPS target: " << adaptiveFramerateTarget << std::endl;
+
 
 		elapsedFrameTime = frameClock.getElapsedTime();
 		intendedSleepDuration = assumedFrameTime - elapsedFrameTime;
 
 		// There is time to sleep
 		if (intendedSleepDuration > sf::Time::Zero) {
 
 			//timeBeginPeriod(1); // Setting this at program start gives better accuracy
 			sf::sleep(intendedSleepDuration);
 			//timeEndPeriod(1);
 
 			afterSleepTime = frameClock.getElapsedTime();
 			actualSleepDuration = afterSleepTime - elapsedFrameTime;
 			oversleepDuration = actualSleepDuration - intendedSleepDuration;
 			correctiveFrameTime = idealFrameTime - oversleepDuration;
 
 			if (correctiveFrameTime < minAdaptiveFrameTimeMicros) {
 				correctiveFrameTime = minAdaptiveFrameTimeMicros;
 			} else if (correctiveFrameTime > maxAdaptiveFrameTimeMicros) {
 				correctiveFrameTime = maxAdaptiveFrameTimeMicros;
 			}
 
 			recentMicros = correctiveFrameTime.asMicroseconds();
 			oldMicros = frameTimeMemoryMicros[frameTimeOldestMemorySlot];
 
 			frameTimeMemoryMicrosSum += recentMicros - oldMicros;
 			frameTimeMemoryMicros[frameTimeOldestMemorySlot] = recentMicros;
 			frameTimeOldestMemorySlot = (frameTimeOldestMemorySlot + 1) % frameTimeMemorySize;
 
 			assumedFrameTime = sf::microseconds(frameTimeMemoryMicrosSum / frameTimeMemorySize);
 		} // else don't touch the adaptive FPS we have "learned" so far, and just move on.
 	}
 
 	glFinish(); // If the frame is still not done rendering, block.
 }