improve handling of fps limits with frameTick()

Author: nmwsharp

examples/demo-app/demo_app.cpp

@@ -944,11 +944,12 @@ int main(int argc, char** argv) {
   } else {
     // Show the gui
     polyscope::show();
+
+    // main loop using manual frameTick() instead
+    // while (!polyscope::windowRequestsClose()) {
+    //   polyscope::frameTick();
+    // }
   }
-  // main loop using manual frameTick() instead
-  // while (true) {
-  //   polyscope::frameTick();
-  // }
 
   std::cout << "!!!! shutdown time" << std::endl;
   polyscope::shutdown();

include/polyscope/options.h

@@ -41,6 +41,10 @@ extern int maxFPS;
 // NOTE: some platforms may ignore the setting.
 extern bool enableVSync;
 
+// When using the alternate `frameTick()` control flow instead of `show()`, should framerate-limiting maxFPS/vsync
+// features be respected? (which might caues the program to block on the call to frameTick()). (default: false)
+extern bool frameTickLimitFPS;
+
 // Read preferences (window size, etc) from startup file, write to same file on exit (default: true)
 extern bool usePrefsFile;
 

src/options.cpp

@@ -13,13 +13,13 @@ bool allowHeadlessBackends = false;
 bool errorsThrowExceptions = false;
 bool debugDrawPickBuffer = false;
 int maxFPS = 60;
-
 #ifdef _WIN32
 // set the default vsync to false on windows, to workaround an glfw errors from an alleged driver bug
 bool enableVSync = false;
 #else
 bool enableVSync = true;
 #endif
+bool frameTickLimitFPS = false;
 
 bool usePrefsFile = true;
 bool initializeWithDefaultStructures = true;

src/polyscope.cpp

@@ -153,6 +153,22 @@ std::map<std::string, std::unique_ptr<Structure>>& getStructureMapCreateIfNeeded
   return state::structures[typeName];
 }
 
+void sleepForFramerate() {
+  // If needed, block the program execution to hit the intended framerate
+  // (if not used, the render loop may busy-run maxed out at 1000+ fps and waste resources)
+  if (options::maxFPS != -1) {
+    auto currTime = std::chrono::steady_clock::now();
+    long microsecPerLoop = 1000000 / options::maxFPS;
+    microsecPerLoop = (95 * microsecPerLoop) / 100; // give a little slack so we actually hit target fps
+    while (std::chrono::duration_cast<std::chrono::microseconds>(currTime - lastMainLoopIterTime).count() <
+           microsecPerLoop) {
+      std::this_thread::yield();
+      currTime = std::chrono::steady_clock::now();
+    }
+  }
+  lastMainLoopIterTime = std::chrono::steady_clock::now();
+}
+
 } // namespace
 
 // === Core global functions
@@ -239,19 +255,7 @@ void pushContext(std::function<void()> callbackFunction, bool drawDefaultUI) {
   size_t currentContextStackSize = contextStack.size();
   while (contextStack.size() >= currentContextStackSize) {
 
-    // The windowing system will let the main loop busy-loop on some platforms. Make sure that doesn't happen.
-    if (options::maxFPS != -1) {
-      auto currTime = std::chrono::steady_clock::now();
-      long microsecPerLoop = 1000000 / options::maxFPS;
-      microsecPerLoop = (95 * microsecPerLoop) / 100; // give a little slack so we actually hit target fps
-      while (std::chrono::duration_cast<std::chrono::microseconds>(currTime - lastMainLoopIterTime).count() <
-             microsecPerLoop) {
-        std::this_thread::yield();
-        currTime = std::chrono::steady_clock::now();
-      }
-    }
-    lastMainLoopIterTime = std::chrono::steady_clock::now();
-
+    sleepForFramerate();
     mainLoopIteration();
 
     // auto-exit if the window is closed
@@ -305,9 +309,29 @@ void frameTick() {
   // Make sure we're visible
   render::engine->showWindow();
 
-  // All-imporant main loop iteration
+  bool savedVsyncValue = false; // see below
+  bool needToRestoreVSyncValue =
+      false; // we need this as a saved bool, because the setting could change during mainLoopIteration()
+  if (options::frameTickLimitFPS) {
+    sleepForFramerate();
+  } else {
+    // Ugly workaround to preserve the API:
+    // We want vsync to be disabled unless frameTick(limitFPS=True), so that we don't slow down user's application.
+    // But it's currently a bool read in the render call and I don't want to change that API. So we temporarily set
+    // it to false and restore the value after.
+    // ONEDAY: when we have a major version update, change the API on the vsync setting to make this unecessary
+    savedVsyncValue = options::enableVSync;
+    options::enableVSync = false;
+    needToRestoreVSyncValue = true;
+  }
+
   mainLoopIteration();
 
+  if (needToRestoreVSyncValue) {
+    // restore saved value, see note above
+    options::enableVSync = savedVsyncValue;
+  }
+
   frameTickStack--;
 }
 
@@ -705,6 +729,15 @@ void buildPolyscopeGui() {
     ImGui::Text("Last: %.1f ms/frame (%.1f fps)", ImGui::GetIO().DeltaTime * 1000.f, 1.f / ImGui::GetIO().DeltaTime);
 
     ImGui::PushItemWidth(40 * options::uiScale);
+
+    bool isFrameTickShow = frameTickStack > 0;
+    if (isFrameTickShow) {
+      ImGui::Checkbox("limit fps", &options::frameTickLimitFPS);
+      ImGui::SameLine();
+    }
+
+    ImGui::BeginDisabled(isFrameTickShow && !options::frameTickLimitFPS);
+
     if (ImGui::InputInt("max fps", &options::maxFPS, 0)) {
       if (options::maxFPS < 1 && options::maxFPS != -1) {
         options::maxFPS = -1;
@@ -715,6 +748,8 @@ void buildPolyscopeGui() {
     ImGui::SameLine();
     ImGui::Checkbox("vsync", &options::enableVSync);
 
+    ImGui::EndDisabled();
+
     ImGui::TreePop();
   }