Try a different cache refresh on lag strategy

linuxinstall/com.infinipaint.infinipaint.metainfo.xml

@@ -8,7 +8,7 @@
     <project_license>MIT</project_license>
 
     <branding>
-        <color type="primary" scheme_preference="light">#8ff7ea</color>
+        <color type="primary" scheme_preference="light">#83b9b2</color>
         <color type="primary" scheme_preference="dark">#325652</color>
     </branding>
     

src/DrawingProgram/DrawingProgram.cpp

@@ -233,6 +233,25 @@ void DrawingProgram::tool_options_gui() {
 }
 
 void DrawingProgram::update() {
+    if(world.main.window.lastFrameTime > std::chrono::milliseconds(33)) { // Around 30FPS
+        if(!badFrametimeTimePoint)
+            badFrametimeTimePoint = std::chrono::steady_clock::now();
+        else if(unorderedObjectsExistTimePoint && std::chrono::steady_clock::now() - badFrametimeTimePoint.value() >= std::chrono::seconds(5) && std::chrono::steady_clock::now() - unorderedObjectsExistTimePoint.value() >= std::chrono::seconds(5)) {
+            force_rebuild_cache();
+            unorderedObjectsExistTimePoint = std::nullopt;
+            badFrametimeTimePoint = std::nullopt;
+        }
+    }
+    else
+        badFrametimeTimePoint = std::nullopt;
+
+    if(compCache.get_unsorted_component_list().empty()) {
+        unorderedObjectsExistTimePoint = std::nullopt;
+    }
+    else if(!unorderedObjectsExistTimePoint) {
+        unorderedObjectsExistTimePoint = std::chrono::steady_clock::now();
+    }
+
     if(drawTool->get_type() == DrawingProgramToolType::BRUSH && world.main.input.pen.isEraser && !temporaryEraser) {
         switch_to_tool(DrawingProgramToolType::ERASER);
         temporaryEraser = true;
@@ -569,8 +588,6 @@ void DrawingProgram::write_to_file(cereal::PortableBinaryOutputArchive& a) {
 }
 
 void DrawingProgram::draw(SkCanvas* canvas, const DrawData& drawData) {
-    std::chrono::microseconds timeToDrawUnsortedComponents(0);
-
     if(drawData.dontUseDrawProgCache) {
         parallel_loop_all_components([&](auto& c) {
             c->obj->calculate_draw_transform(drawData);
@@ -584,9 +601,7 @@ void DrawingProgram::draw(SkCanvas* canvas, const DrawData& drawData) {
         canvas->saveLayer(nullptr, nullptr);
             canvas->clear(SkColor4f{0.0f, 0.0f, 0.0f, 0.0f});
             compCache.refresh_all_draw_cache(drawData);
-            compCache.draw_components_to_canvas(canvas, drawData, {
-                .timeToDrawUnsortedComponents = &timeToDrawUnsortedComponents
-            });
+            compCache.draw_components_to_canvas(canvas, drawData, {});
             canvas->saveLayer(nullptr, nullptr);
                 selection.draw_components(canvas, drawData);
             canvas->restore();
@@ -595,11 +610,6 @@ void DrawingProgram::draw(SkCanvas* canvas, const DrawData& drawData) {
     }
 
     drawTool->draw(canvas, drawData);
-
-    // 10ms is an arbitrary value. If drawing only the unsorted components takes more than that amount of time,
-    // they're definitely causing lag and must be sorted so that they can be cached
-    if(timeToDrawUnsortedComponents >= std::chrono::microseconds(10000))
-        force_rebuild_cache();
 }
 
 Vector4f* DrawingProgram::get_foreground_color_ptr() {

src/DrawingProgram/DrawingProgram.hpp

@@ -56,6 +56,9 @@ class DrawingProgram {
 
         void clear_draw_cache();
     private:
+        std::optional<std::chrono::steady_clock::time_point> badFrametimeTimePoint;
+        std::optional<std::chrono::steady_clock::time_point> unorderedObjectsExistTimePoint;
+
         void client_erase_set(std::unordered_set<CollabListType::ObjectInfoPtr> erasedComponents); // The set might be modified while this is being called, so dont pass by reference
 
         void check_delayed_update_timers();

src/DrawingProgram/DrawingProgramCache.cpp

@@ -454,9 +454,6 @@ void DrawingProgramCache::draw_components_to_canvas(SkCanvas* canvas, const Draw
 
     if(optData.lastDrawnComponentPlacement)
         *optData.lastDrawnComponentPlacement = lastComponentDrawn;
-
-    if(optData.timeToDrawUnsortedComponents)
-        *optData.timeToDrawUnsortedComponents = unsortedCompDrawTime;
 }
 
 void DrawingProgramCache::draw_cache_image_to_canvas(SkCanvas* canvas, const DrawData& drawData, const std::shared_ptr<DrawingProgramCacheBVHNode>& bvhNode) {

src/DrawingProgram/DrawingProgramCache.hpp

@@ -35,7 +35,7 @@ class DrawingProgramCache {
         ~DrawingProgramCache();
 
         static constexpr size_t MINIMUM_COMPONENTS_TO_START_REBUILD = 1000;
-        static constexpr size_t MAXIMUM_COMPONENTS_IN_SINGLE_NODE = 100;
+        static constexpr size_t MAXIMUM_COMPONENTS_IN_SINGLE_NODE = 50;
 
         bool check_if_rebuild_should_occur();
         void test_rebuild(const std::vector<CollabListType::ObjectInfoPtr>& comps, bool force = false);
@@ -60,7 +60,6 @@ class DrawingProgramCache {
         struct DrawComponentsToCanvasOptionalData {
             uint64_t* lastDrawnComponentPlacement = nullptr;
             std::optional<SCollision::AABB<WorldScalar>> drawBounds;
-            std::chrono::microseconds* timeToDrawUnsortedComponents = nullptr;
         };
 
         void draw_components_to_canvas(SkCanvas* canvas, const DrawData& drawData, DrawComponentsToCanvasOptionalData optData);

src/MainProgram.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include "DrawData.hpp"
 #include "GridManager.hpp"
+#include <chrono>
 #include <include/core/SkCanvas.h>
 #include "InputManager.hpp"
 #include "FontData.hpp"
@@ -31,6 +32,7 @@ class MainProgram {
         Vector3f userColor;
 
         struct Window {
+            std::chrono::steady_clock::duration lastFrameTime = std::chrono::milliseconds(16);
             Vector2i size = {-1, -1};
             Vector2i pos = {-1, -1};
             Vector2i writtenSize = {-1, -1};

src/main.cpp

@@ -520,6 +520,7 @@ SDL_AppResult SDL_AppInit(void **appstate, int argc, char **argv) {
 }
 
 SDL_AppResult SDL_AppIterate(void *appstate) {
+    std::chrono::steady_clock::time_point frameTimeStart = std::chrono::steady_clock::now();
 
     MainStruct& mS = *((MainStruct*)appstate);
 #ifdef NDEBUG
@@ -584,6 +585,8 @@ SDL_AppResult SDL_AppIterate(void *appstate) {
     }
 #endif
 
+    mS.m->window.lastFrameTime = std::chrono::steady_clock::now() - frameTimeStart;
+
     return SDL_APP_CONTINUE;
 }