Qor idle modes, tick+fps decoupling, small fixes

Author: flipcoder

Qor/Input.h

@@ -501,7 +501,7 @@ class Input:
 
         void gamepad_require_focus(bool b);
         void mouse_require_focus(bool b);
-        
+
     private:
 
         bool m_bRelMouse = false;
@@ -537,6 +537,13 @@ class Input:
         std::vector<SDL_Joystick*> m_Joysticks;
 
         std::atomic<bool> m_bEscape = ATOMIC_VAR_INIT(false);
+
+        // triggers when an event needs to wake the Pipeline idle process
+        boost::signals2::signal<void()> on_wakeup;
+        
+        // The current event polling interval (usually 0).
+        // Intended for use in Pipeline idle
+        Freq::Time m_PollInterval;
 };
 
 // Inherit from this to make interfaces to controllable objects
@@ -706,6 +713,9 @@ class Controller:
         //std::vector<std::string> m_BindNames;
         std::vector<std::weak_ptr<IInterface>> m_Interfaces;
 
+        //bool m_bIdle = false;
+        //bool m_bDirty = false;
+
         //boost::signals2::signal<void()> 
 };
 

Qor/LoadingState.cpp

@@ -115,12 +115,12 @@ LoadingState :: LoadingState(Qor* qor):
     //fade_to(Color::white(), m_FadeTime);
     m_Fade.frame(Frame<Color>(
         Color::white(),
-        Freq::Time::seconds(0.5f),
+        Freq::Time::seconds(0.25f),
         INTERPOLATE(out_sine<Color>)
     ));
     //m_Fade.frame(Frame<Color>(
     //    Color::white(), // wait a while
-    //    Freq::Time::seconds(1.0f),
+    //    Freq::Time::seconds(0.25f),
     //    INTERPOLATE(Color, out_sine)
     //));
 #ifndef QOR_NO_AUDIO
@@ -207,7 +207,7 @@ void LoadingState :: logic(Freq::Time t)
             {
                 m_Fade.frame(Frame<Color>(
                     Color::black(),
-                    Freq::Time::seconds(0.5f),
+                    Freq::Time::seconds(0.25f),
                     INTERPOLATE(out_sine<Color>)
                 ));
             }

Qor/Main.cpp

@@ -21,6 +21,9 @@ int main(int argc, char* argv[])
     Args args(argc, (const char**)argv);
 
     auto engine = kit::make_unique<Qor>(args, Info::Program);
+
+    //engine->max_tick(300.0f);
+    //engine->max_fps(30.0f);
 
     if(engine->args().value_or("mod", "").empty())
         engine->states().register_class<BasicState>(); // run basic state

Qor/Pipeline.cpp

@@ -91,6 +91,7 @@ Pipeline :: ~Pipeline()
 
 void Pipeline :: backfaces(bool b)
 {
+    auto l = this->lock();
     GL_TASK_START()
         if(b)
             glDisable(GL_CULL_FACE);
@@ -101,6 +102,13 @@ void Pipeline :: backfaces(bool b)
 
 void Pipeline :: logic(Freq::Time t)
 {
+    auto l = this->lock();
+    if(m_Idle & IDLE_LOGIC){
+        if(not m_bDirty)
+            return;
+        else
+            m_bDirty = false;
+    }
     m_pPartitioner->logic(t);
 }
 
@@ -260,6 +268,13 @@ void Pipeline :: render(
     unsigned flags
 ){
     auto l = this->lock();
+    if(m_Idle & IDLE_RENDER){
+        if(not m_bDirty)
+            return;
+        else
+            m_bDirty = false;
+    }
+    
     assert(m_pWindow);
     if(not partitioner)
         partitioner = m_pPartitioner.get();
@@ -268,6 +283,7 @@ void Pipeline :: render(
         return;
     if(!camera)
         return;
+
     //if(!m_pRoot.lock())
     //    return;
     //if(!m_pCamera.lock())
@@ -489,6 +505,7 @@ void Pipeline :: render(
 
 void Pipeline :: winding(bool cw)
 {
+    auto l = this->lock();
     GL_TASK_START()
         glFrontFace(cw ? GL_CW : GL_CCW);
     GL_TASK_END()

Qor/Pipeline.h

@@ -181,6 +181,33 @@ class Pipeline:
         void override_shader(PassType p, unsigned id);
         void clear_shader_overrides();
         std::shared_ptr<Program> shader();
+
+        enum IdleMode {
+            NO_IDLE = 0,
+            IDLE_LOGIC = kit::bit(0),
+            IDLE_RENDER = kit::bit(1),
+            IDLE = kit::bit(0) | kit::bit(1)
+        };
+        int idle() const {
+            auto l = this->lock();
+            return m_Idle;
+        }
+        void idle(int mode) {
+            auto l = this->lock();
+            m_Idle = mode;
+        }
+        bool dirty() const { 
+            auto l = this->lock();
+            return m_bDirty;
+        }
+        void dirty(bool b) {
+            auto l = this->lock();
+            m_bDirty = b;
+        }
+        void redraw() {
+            auto l = this->lock();
+            m_bDirty = true;
+        }
 
     private:
 
@@ -228,6 +255,9 @@ class Pipeline:
         const static std::vector<std::string> s_AttributeNames;
 #endif
 
+        int m_Idle = NO_IDLE;
+        bool m_bDirty = false;
+        
         std::function<void()> m_BlendFunc;
 };
 

Qor/Qor.cpp

@@ -116,13 +116,15 @@ Qor :: Qor(const Args& args, std::string appname="qor"):
 #endif
 
     m_pWindow = make_shared<Window>(m_Args, &m_Resources);
+    m_MaxFPS = m_pWindow->refresh_rate();
 
     //auto& renderer = CEGUI::OpenGLRenderer::bootstrapSystem();
     //CEGUI::OpenGLRenderer::create();
     //CEGUI::System::create(renderer);
 
     m_pInput = make_shared<Input>(m_pWindow.get());
     m_pTimer = make_shared<Freq>();
+    m_TPSAlarm.timer(m_pTimer->timeline());
     m_FPSAlarm.timer(m_pTimer->timeline());
     //m_pGUI = make_shared<GUI>(m_pTimer.get(), m_pWindow.get(), &m_Resources);
     //m_pGUI->init();
@@ -167,6 +169,7 @@ Qor :: Qor(const Args& args, std::string appname="qor"):
     //m_pCanvas = kit::make_unique<Canvas>(m_pWindow->size().x, m_pWindow->size().y);
     m_pPipeline = make_shared<Pipeline>(m_pWindow.get(), m_Args, &m_Resources);
 
+    m_TPSAlarm.set(Freq::Time::seconds(1.0f));
     m_FPSAlarm.set(Freq::Time::seconds(1.0f));
 }
 
@@ -182,24 +185,38 @@ Qor :: ~Qor()
 void Qor :: logic()
 {
     Freq::Time t;
-    if(m_FPSAlarm.elapsed()) {
-        m_FPSAlarm.set(Freq::Time::seconds(1.0f));
-        m_FPS = m_FramesLastSecond;
-        LOGf("FPS: %s", m_FPS);
-        m_FramesLastSecond = 0;
+    if(m_TPSAlarm.elapsed()) {
+        m_TPSAlarm.set(Freq::Time::seconds(1.0f));
+        m_TPS = m_TicksLastSecond;
+        LOGf("Ticks: %s", m_TPS);
+        m_TicksLastSecond = 0;
     }
-    while(!(t = m_pTimer->tick()).ui())
+    m_TickAccum = 0;
+    while(true)
     {
+        // accumulated enough time to advance?
+        t = m_pTimer->tick();
+        m_TickAccum += t.s();
+        m_FrameAccum += t.s();
+        if(m_MaxTick < K_EPSILON) // MaxTick==0 for unlimited ticks
+            break;
+        if((m_TickAccum > 1.0f/m_MaxTick) ||
+            (m_MaxFPS > K_EPSILON && m_FrameAccum > 1.0f/m_MaxFPS))
+            break;
         try{
             this_thread::yield();
         }catch(...){
             quit();
             return;
         }
     }
-    //t = m_pTimer->tick();
-    ++m_FramesLastSecond;
+    //LOGf("%s", m_TickAccum);
+    
+    ++m_TicksLastSecond;
 
+    bool pipeline_dirty = m_pPipeline->dirty();
+    int pipeline_idlemode = m_pPipeline->idle();
+    
     m_pInput->logic(t);
     if(m_pInput->quit_flag())
     {
@@ -208,17 +225,39 @@ void Qor :: logic()
     }
     //m_pAudio->logic(t.ms());
 
+    // Get pipeline idlemode and dirty state BEFORE logic() (since this changes)
+    // Do not execute state logic if pipeline is using logic idle mode
     m_pPipeline->logic(t);
-    if(state()){
-        state()->logic(t);
-    }
+    if(not (pipeline_idlemode & Pipeline::IDLE_LOGIC) || pipeline_dirty)
+        if(state()){
+            state()->logic(t);
+        }
 }
 
 void Qor :: render()
 {
     if(Headless::enabled())
         return;
-        
+
+    bool pipeline_dirty = m_pPipeline->dirty();
+    int pipeline_idlemode = m_pPipeline->idle();
+    if((pipeline_idlemode & Pipeline::IDLE_RENDER) && not pipeline_dirty)
+        return;
+
+    if(m_FPSAlarm.elapsed()) {
+        m_FPSAlarm.set(Freq::Time::seconds(1.0f));
+        m_FPS = m_FramesLastSecond;
+        LOGf("FPS: %s", m_FPS);
+        m_FramesLastSecond = 0;
+    }
+
+    if(m_MaxFPS > K_EPSILON) // max fps limit?
+        if(m_FrameAccum < 1.0f/m_MaxFPS) // not time for frame
+            return; // do more logic() before render
+    m_FrameAccum = 0;
+    
+    ++m_FramesLastSecond;
+
     if(state())
         state()->render();
     m_pWindow->render();

Qor/Qor.h

@@ -210,6 +210,8 @@ class Qor:
         }
         void max_fps(float fps) {m_MaxFPS=fps;}
         float max_fps() const { return m_MaxFPS; }
+        void max_tick(float tick) {m_MaxTick=tick;}
+        float max_tick() const { return m_MaxTick; }
 
         static Qor* get() { return s_pQor; } // try not to use this ;'(
 
@@ -249,6 +251,7 @@ class Qor:
         std::atomic<bool> m_bQuit = ATOMIC_VAR_INIT(false);
 
         float m_MaxFPS = 300.0f;
+        float m_MaxTick = 300.0f;
 
         // Engine components
         std::shared_ptr<Window> m_pWindow;
@@ -276,8 +279,15 @@ class Qor:
 
         std::vector<std::string> m_SearchPaths;
 
+        float m_TickAccum = 0.0f;
+        float m_FrameAccum = 0.0f;
+        float m_TickDelay = 0.0f;
+        
+        Freq::Alarm m_TPSAlarm;
         Freq::Alarm m_FPSAlarm;
+        unsigned m_TicksLastSecond = 0;
         unsigned m_FramesLastSecond = 0;
+        float m_TPS = 0.0f;
         float m_FPS = 0.0f;
         std::string m_App;
 

Qor/Window.cpp

@@ -86,8 +86,13 @@ Window :: Window(
             if(video_cfg->has("anisotropy"))
                 Texture::set_anisotropy(float(video_cfg->at<int>("anisotropy")));
 
-            if(video_cfg->at("vsync", false))
+            if(video_cfg->at("vsync", false)){
                 SDL_GL_SetSwapInterval(1);
+                SDL_SetHintWithPriority(SDL_HINT_RENDER_VSYNC, "1", SDL_HINT_OVERRIDE);
+            }else{
+                SDL_GL_SetSwapInterval(0);
+                SDL_SetHintWithPriority(SDL_HINT_RENDER_VSYNC, "0", SDL_HINT_OVERRIDE);
+            }
 
             m_pWindow = SDL_CreateWindow(
                 m_Title.c_str(),
@@ -106,6 +111,15 @@ Window :: Window(
                 //SDL_WINDOW_RESIZABLE
             );
 
+            SDL_DisplayMode current;
+            for(int i = 0; i < SDL_GetNumVideoDisplays(); ++i){
+                int r = SDL_GetCurrentDisplayMode(i, &current);
+                if(r != 0)
+                    m_RefreshRate = std::max(current.refresh_rate, m_RefreshRate);
+            }
+            if(video_cfg->has("refreshrate"))
+                m_RefreshRate = video_cfg->at<int>("refreshrate");
+
             if(!m_pWindow)
                 K_ERROR(GENERAL, SDL_GetError());
 

Qor/Window.h

@@ -65,6 +65,7 @@ class Window
 
         boost::signals2::signal<void()> on_delay;
 
+        int refresh_rate() const { return m_RefreshRate; }
 
     private:
 
@@ -80,6 +81,7 @@ class Window
         mutable bool m_DelayReady = false;
         mutable bool m_DelayDone = false;
         mutable bool m_QuitFlag = false;
+        int m_RefreshRate = 60;
 };
 
 #endif

bin/settings.schema.json

@@ -28,6 +28,10 @@
             ".name": "Vertical Sync",
             ".desc": "Reduces tearing but may lower frame rate",
             ".values": [ false, true ]
+        },
+        "refreshrate": {
+            ".name": "Refresh Rate",
+            ".desc": "Display refresh rate estimate"
         }
     },
 

sg.json

@@ -5,9 +5,6 @@
         }
     },
     "required": {
-        "flipcoder/kit": {
-            "link": "kit"
-        },
         "glew": "*",
         "boost": "*",
         "openal": "*",
@@ -16,7 +13,7 @@
         "pangomm": "*",
         "libogg": "*",
         "libvorbis": "*",
-        "devil": "*",
+        "freeimage": "*",
         "g-truc/glm": "*",
         "rapidxml": "*",
         "jsoncpp": "*"