comparison layer/RenderTimer.h @ 1324:13d9b422f7fe zoom

Merge from default branch

 
 class RenderTimer
 {
 public:
     enum Type {
-	/// A normal rendering operation with normal responsiveness demands
-	FastRender,
+        /// A normal rendering operation with normal responsiveness demands
+        FastRender,
 
-	/// An operation that the user might accept being slower
-	SlowRender,
+        /// An operation that the user might accept being slower
+        SlowRender,
 
-	/// An operation that should always complete, i.e. as if there
-	/// were no RenderTimer in use, but without having to change
-	/// client code structurally
-	NoTimeout
+        /// An operation that should always complete, i.e. as if there
+        /// were no RenderTimer in use, but without having to change
+        /// client code structurally
+        NoTimeout
     };
     
     /**
      * Create a new RenderTimer and start timing. Make one of these
      * before rendering, and then call outOfTime() regularly during
      * rendering. If outOfTime() returns true, abandon rendering!  and
      * schedule the rest for after some user responsiveness has
      * happened.
      */
     RenderTimer(Type t) :
-	m_start(std::chrono::steady_clock::now()),
-	m_haveLimits(true),
-	m_minFraction(0.1),
-	m_softLimit(0.1),
-	m_hardLimit(0.2),
-	m_softLimitOverridden(false) {
+        m_start(std::chrono::steady_clock::now()),
+        m_haveLimits(true),
+        m_minFraction(0.1),
+        m_softLimit(0.1),
+        m_hardLimit(0.2),
+        m_softLimitOverridden(false) {
 
-	if (t == NoTimeout) {
-	    m_haveLimits = false;
-	} else if (t == SlowRender) {
-	    m_softLimit = 0.2;
-	    m_hardLimit = 0.4;
-	}
+        if (t == NoTimeout) {
+            m_haveLimits = false;
+        } else if (t == SlowRender) {
+            m_softLimit = 0.2;
+            m_hardLimit = 0.4;
+        }
     }
 
 
     /**
      * Return true if we have run out of time and should suspend

      * of how much of the work has been done as of this call, as a
      * number between 0.0 (none of it) and 1.0 (all of it).
      */
     bool outOfTime(double fractionComplete) {
 
-	if (!m_haveLimits || fractionComplete < m_minFraction) {
-	    return false;
-	}
-	
-	auto t = std::chrono::steady_clock::now();
-	double elapsed = std::chrono::duration<double>(t - m_start).count();
-	
-	if (elapsed > m_hardLimit) {
-	    return true;
-	} else if (!m_softLimitOverridden && elapsed > m_softLimit) {
-	    if (fractionComplete > 0.6) {
-		// If we're significantly more than half way by the
-		// time we reach the soft limit, ignore it (though
-		// always respect the hard limit, above). Otherwise
-		// respect the soft limit and report out of time now.
-		m_softLimitOverridden = true;
-	    } else {
-		return true;
-	    }
-	}
+        if (!m_haveLimits || fractionComplete < m_minFraction) {
+            return false;
+        }
+        
+        auto t = std::chrono::steady_clock::now();
+        double elapsed = std::chrono::duration<double>(t - m_start).count();
+        
+        if (elapsed > m_hardLimit) {
+            return true;
+        } else if (!m_softLimitOverridden && elapsed > m_softLimit) {
+            if (fractionComplete > 0.6) {
+                // If we're significantly more than half way by the
+                // time we reach the soft limit, ignore it (though
+                // always respect the hard limit, above). Otherwise
+                // respect the soft limit and report out of time now.
+                m_softLimitOverridden = true;
+            } else {
+                return true;
+            }
+        }
 
-	return false;
+        return false;
+    }
+
+    double secondsPerItem(int itemsRendered) const {
+
+        if (itemsRendered == 0) return 0.0;
+
+        auto t = std::chrono::steady_clock::now();
+        double elapsed = std::chrono::duration<double>(t - m_start).count();
+
+        return elapsed / itemsRendered;
     }
 
 private:
     std::chrono::time_point<std::chrono::steady_clock> m_start;
     bool m_haveLimits;
-    double m_minFraction;
-    double m_softLimit;
-    double m_hardLimit;
+    double m_minFraction; // proportion, 0.0 -> 1.0
+    double m_softLimit; // seconds
+    double m_hardLimit; // seconds
     bool m_softLimitOverridden;
 };
 
 #endif