Improved Source Callback for multi-callbacks compatibility

Source.cpp

@@ -644,31 +644,31 @@ void Source::call(SourceCallback *callback, bool override)
         // look for callbacks of same type
         for (auto iter=update_callbacks_.begin(); iter != update_callbacks_.end(); )
         {
-            // there can be only one callback of same type in a source
+            // Test if the new callback would overlap an existing one
             SourceCallback *c = *iter;
-            if (callback->type() == c->type() ) {
+            if ( SourceCallback::overlap( callback, c) ) {
                 if (override) {
-                    // either remove and delete all callbacks of same type if override
+                    // either remove and delete all overlapping callbacks if override...
                     iter = update_callbacks_.erase(iter);
                     delete c;
                 }
                 else {
-                    // or cancel adding callbacks of same type if not override
+                    // ...or cancel adding overlapping callbacks if not override
                     add = false;
                     break;
                 }
             }
-            // iterate over other types
+            // iterate
             else
                 ++iter;
         }
 
-        // we can add the callback as there is none of that type or we override
+        // we can add the callback : its either not overlapping or we override it
         if (add) {
             // add callback to callbacks list
             update_callbacks_.push_back(callback);
         }
-        // or delete it if couln't be added (not override)
+        // or delete it if couln't be added (overlapping but not override)
         else
             delete callback;
 
@@ -772,11 +772,10 @@ void Source::updateCallbacks(float dt)
     for (auto iter=update_callbacks_.begin(); iter != update_callbacks_.end(); )
     {
         SourceCallback *callback = *iter;
-        // call update for active callbacks
-        if (callback->active()) {
-            callback->update(this, dt);
-            need_update_ = true;
-        }
+
+        // call update on callbacks
+        callback->update(this, dt);
+        need_update_ = true;
 
         // remove and delete finished callbacks
         if (callback->finished()) {

SourceCallback.cpp

@@ -67,7 +67,49 @@ SourceCallback *SourceCallback::create(CallbackType type)
     return loadedcallback;
 }
 
-SourceCallback::SourceCallback(): active_(true), finished_(false), initialized_(false)
+
+bool SourceCallback::overlap( SourceCallback *a,  SourceCallback *b)
+{
+    bool ret = false;
+
+    if (a->type() == b->type()) {
+
+        // same type means overlap
+        ret = true;
+
+        // but there are some exceptions..
+        switch (a->type()) {
+        case SourceCallback::CALLBACK_GRAB:
+        {
+            const Grab *_a = static_cast<Grab*>(a);
+            const Grab *_b = static_cast<Grab*>(b);
+            // there is no overlap if the X or Y of a vector is zero
+            if ( ABS(_a->value().x) < EPSILON || ABS(_b->value().x) < EPSILON )
+                ret = false;
+            else if ( ABS(_a->value().y) < EPSILON || ABS(_b->value().y) < EPSILON )
+                ret = false;
+        }
+            break;
+        case SourceCallback::CALLBACK_RESIZE:
+        {
+            const Resize *_a = static_cast<Resize*>(a);
+            const Resize *_b = static_cast<Resize*>(b);
+            if ( ABS(_a->value().x) < EPSILON || ABS(_b->value().x) < EPSILON )
+                ret = false;
+            else if ( ABS(_a->value().y) < EPSILON || ABS(_b->value().y) < EPSILON )
+                ret = false;
+        }
+            break;
+        default:
+            break;
+        }
+
+    }
+
+    return ret;
+}
+
+SourceCallback::SourceCallback(): finished_(false), initialized_(false)
 {
 }
 

SourceCallback.h

@@ -25,6 +25,7 @@ public:
     } CallbackType;
 
     static SourceCallback *create(CallbackType type);
+    static bool overlap(SourceCallback *a, SourceCallback *b);
 
     SourceCallback();
     virtual ~SourceCallback() {}
@@ -33,15 +34,13 @@ public:
     virtual void multiply (float) {};
     virtual SourceCallback *clone () const = 0;
     virtual SourceCallback *reverse (Source *) const { return nullptr; }
-    virtual CallbackType type () { return CALLBACK_GENERIC; }
+    virtual CallbackType type () const { return CALLBACK_GENERIC; }
     virtual void accept (Visitor& v);
 
     inline bool finished () const { return finished_; }
-    inline bool active () const { return active_; }
     inline void reset () { initialized_ = false; }
 
 protected:
-    bool active_;
     bool finished_;
     bool initialized_;
 };
@@ -52,7 +51,7 @@ public:
     ResetGeometry () : SourceCallback() {}
     void update (Source *s, float) override;
     SourceCallback *clone () const override;
-    CallbackType type () override { return CALLBACK_RESETGEO; }
+    CallbackType type () const override { return CALLBACK_RESETGEO; }
 };
 
 class SetAlpha : public SourceCallback
@@ -72,7 +71,7 @@ public:
     void multiply (float factor) override;
     SourceCallback *clone () const override;
     SourceCallback *reverse(Source *s) const override;
-    CallbackType type () override { return CALLBACK_ALPHA; }
+    CallbackType type () const override { return CALLBACK_ALPHA; }
     void accept (Visitor& v) override;
 };
 
@@ -96,7 +95,7 @@ public:
     void update (Source *s, float) override;
     void multiply (float factor) override;
     SourceCallback *clone() const override;
-    CallbackType type () override { return CALLBACK_LOOM; }
+    CallbackType type () const override { return CALLBACK_LOOM; }
     void accept (Visitor& v) override;
 };
 
@@ -113,7 +112,7 @@ public:
 
     void update (Source *s, float) override;
     SourceCallback *clone() const override;
-    CallbackType type () override { return CALLBACK_LOCK; }
+    CallbackType type () const override { return CALLBACK_LOCK; }
 };
 
 class SetDepth : public SourceCallback
@@ -136,7 +135,7 @@ public:
     void multiply (float factor) override;
     SourceCallback *clone () const override;
     SourceCallback *reverse(Source *s) const override;
-    CallbackType type () override { return CALLBACK_DEPTH; }
+    CallbackType type () const override { return CALLBACK_DEPTH; }
     void accept (Visitor& v) override;
 };
 
@@ -154,7 +153,7 @@ public:
     void update (Source *s, float) override;
     SourceCallback *clone() const override;
     SourceCallback *reverse(Source *s) const override;
-    CallbackType type () override { return CALLBACK_PLAY; }
+    CallbackType type () const override { return CALLBACK_PLAY; }
 };
 
 class RePlay : public SourceCallback
@@ -164,7 +163,7 @@ public:
 
     void update(Source *s, float) override;
     SourceCallback *clone() const override;
-    CallbackType type () override { return CALLBACK_REPLAY; }
+    CallbackType type () const override { return CALLBACK_REPLAY; }
 };
 
 class Grab : public SourceCallback
@@ -178,7 +177,7 @@ public:
     Grab();
     Grab(float dx, float dy, float duration = 0.f);
 
-    glm::vec2 value () { return speed_;}
+    glm::vec2 value () const { return speed_;}
     void  setValue (glm::vec2 d) { speed_ = d; }
     float duration () const { return duration_;}
     void  setDuration (float d) { duration_ = d; }
@@ -186,7 +185,7 @@ public:
     void update (Source *s, float) override;
     void multiply (float factor) override;
     SourceCallback *clone () const override;
-    CallbackType type () override { return CALLBACK_GRAB; }
+    CallbackType type () const override { return CALLBACK_GRAB; }
     void accept (Visitor& v) override;
 };
 
@@ -201,7 +200,7 @@ public:
     Resize();
     Resize(float dx, float dy, float duration = 0.f);
 
-    glm::vec2 value () { return speed_;}
+    glm::vec2 value () const { return speed_;}
     void  setValue (glm::vec2 d) { speed_ = d; }
     float duration () const { return duration_;}
     void  setDuration (float d) { duration_ = d; }
@@ -209,7 +208,7 @@ public:
     void update (Source *s, float) override;
     void multiply (float factor) override;
     SourceCallback *clone () const override;
-    CallbackType type () override { return CALLBACK_RESIZE; }
+    CallbackType type () const override { return CALLBACK_RESIZE; }
     void accept (Visitor& v) override;
 };
 
@@ -224,7 +223,7 @@ public:
     Turn();
     Turn(float da, float duration = 0.f);
 
-    float value () { return speed_;}
+    float value () const { return speed_;}
     void  setValue (float d) { speed_ = d; }
     float duration () const { return duration_;}
     void  setDuration (float d) { duration_ = d; }
@@ -232,7 +231,7 @@ public:
     void update (Source *s, float) override;
     void multiply (float factor) override;
     SourceCallback *clone () const override;
-    CallbackType type () override { return CALLBACK_TURN; }
+    CallbackType type () const override { return CALLBACK_TURN; }
     void accept (Visitor& v) override;
 };