kit::make_future, Circuit::sync(), Matrix::scale(), etc.

Author: flipcoder

include/kit/async/multiplexer.h

@@ -256,6 +256,13 @@ class Multiplexer:
                 auto l = lock();
                 return m_Units.empty();
             }
+            void sync() {
+                while(true){
+                    if(empty())
+                        return;
+                    boost::this_thread::yield();
+                };
+            }
             size_t buffered() const {
                 auto l = lock();
                 return m_Buffered;

include/kit/freq/animation.h

@@ -291,10 +291,11 @@ class Animation:
             m_Frames.clear();
         }
         void finish(){
-            process();
             if(!m_Frames.empty()) {
-                m_Current = m_Frames.back().value();
+                auto current = m_Frames.back().value();
+                process();
                 m_Frames.clear();
+                m_Current = current;
             }
         }
         void stop(T position) {

include/kit/kit.h

@@ -607,6 +607,14 @@ namespace kit
         c.erase(std::remove(ENTIRE(c), o), c.end());
     }
 
+    template<class T, class ...Args>
+    std::future<T> make_future(Args&&... args)
+    {
+        std::promise<T> tmp;
+        tmp.set_value(std::forward<Args>(args)...);
+        return tmp.get_future();
+    }
+
     template<class T, class... Args>
     std::unique_ptr<T> make_unique(Args&&... args)
     {

include/kit/math/matrixops.h

@@ -101,11 +101,16 @@ namespace Matrix {
         f[10]=v[2];
         f[15]=1.0f;
     }
-    // assuming uniform scale
-    inline float uniform_scale(glm::mat4& m) {
-        float* f = glm::value_ptr(m);
+    
+    inline float uniform_scale(const glm::mat4& m) {
+        const float* f = glm::value_ptr(m);
         return f[0];
     }
+    inline glm::vec3 scale(const glm::mat4& m) {
+        const float* f = glm::value_ptr(m);
+        return glm::vec3(f[0], f[5], f[10]);
+    }
+
     //inline float average_scale(glm::mat4& m) {
     //    float* f = glm::value_ptr(m);
     //    return (f[0] + f[5] + f[10]) / 3.0f;